I believe the issue is in the fact that that assembly targets WinPhone 8.1 --  [assembly: TargetFramework("WindowsPhone,Version=v8.1", FrameworkDisplayName = "Windows Phone 8.1")].  If your project is targeting WinPhone 8.0 (and not 8.1), the XLabs.Forms.WP8.dll is not deployed even if it is referenced.  That means that there is no associated renderer for the Calendar control.

One way to work around the issue is to add your own renderer for it in .WinPhone project, e.g.:

[assembly: ExportRenderer(typeof(XLabs.Forms.Controls.CalendarView), typeof(YourNamespace.CalendarViewRenderer))]

public class CalendarViewRenderer : ViewRenderer<CalendarView, Calendar>
{
    Calendar calendar = null;

    public CalendarViewRenderer() : base()
    {
        calendar = new Calendar();
        calendar.DateClicked += Calendar_DateClicked;           
    }
     
    protected override void OnElementChanged(ElementChangedEventArgs<CalendarView> e)
    {
        base.SetNativeControl(calendar);
        base.OnElementChanged(e);                       
    }

    private void Calendar_DateClicked(object sender, WPControls.SelectionChangedEventArgs e)
    {
        base.Element.NotifyDateSelected(e.SelectedDate);
    }
}

There are a few well known basic naming rules providing a consistent, understandable REST API services, e.g.

• The scheme and host name are not case sensitive; however, the path and query should be treated as case sensitive.
• Lowercase letters are preferred in URI paths. 
• Do use hyphens (-) between words to improve readability of URI
• Do not use underscore (_) in URIs as this character is often virtually indistinguishable when the content is underlined.

However, quite a few WebAPIs I’ve seen do not adhere to these conventions, so I created (quick and dirty, not fully tested and not production ready) FxCop rules that check for underscores and capital letters in WebAPI implementations.  Feel free to create a dll library type of project, add the files from the listings below and use it in your projects.

WebApiBaseNamingRule.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Microsoft.FxCop.Sdk;

using System.Threading;

using YOURCOMPANY.CodeQuality;

using System.Web.Http.Routing;

using System.Web.Http;

namespace YOURCOMPANY.CodeQuality.WebAPI

{

    public abstract class WebApiBaseNamingRule : BaseIntrospectionRule

    {

        private static Dictionary<string, HttpRoute[]> KnownRoutes = new Dictionary<string, HttpRoute[]>();

        protected static string[] KnownVerbs = Enum.GetNames(typeof(System.Web.Mvc.HttpVerbs));

        public WebApiBaseNamingRule(string name, string resourceName)

            : base(name, resourceName, typeof(WebApiBaseNamingRule).Assembly)

        {

        }

        public abstract ProblemCollection Check(string checkTemplate, string routeTemplate);

        public override ProblemCollection Check(Member member)

        {

            var routes = GetRegisteredApiRoutes(member);

            if (member.DeclaringType.ConstructorName.ToString() == "WebApiConfig" &&

                member.NodeType == NodeType.Method&& 

                (member as Method).Parameters.Count == 1 && (member as Method).Parameters[0].Type.FullName == "System.Web.Http.HttpConfiguration")

            {

                foreach(var r in routes)

                {

                    // Only check literals, i.e. don't check placeholers as they will be replaced when WebAPI is actually used

                    string validateTemplate = RemoteRoutePlaceholders(r.RouteTemplate);

                    Check(validateTemplate, r.RouteTemplate);

                }

            }

            else if (member.DeclaringType.IsApiController()&&  member.IsPublic && !member.IsSpecialName)

            {

                string template = null;

                if (member.HasCustomAttribute("System.Web.Http.RouteAttribute"))

                {

                    var a = member.GetCustomAttribute("System.Web.Http.RouteAttribute");

                    if (a.Expressions.Count > 0)

                    {

                        Literal l = a.Expressions[0] as Literal;

                        if (l != null)

                            template = l.Value as string;

                    }

                }

                if (string.IsNullOrEmpty(template) && member.NodeType == NodeType.Method)

                {

                    // Get matching template

                    string controllerName = RemoveSuffix(member.DeclaringType.Name.ToString(), "controller");

                    var requiredParamsArray = (from p in (member as Method).Parameters

                                               where p.IsOptional == false && p.IsOut == false   // note: IsIn is only set to true if parameter has [in] attribute

                                               select "{" + p.Name + "}").ToArray();

                    string requiredParams = string.Join("/", requiredParamsArray);

                    var action = "/" + member.Name.ToString();

                    if (IsHttpVerb(member.Name.ToString())) // Matching logic in System.Web.Http (packages\Microsoft.AspNet.WebApi.Core.5.2.2\lib\net45\System.Web.Http.dll)

                        action = "";

                    template = "{controller}" + action +

                        (string.IsNullOrEmpty(requiredParams) ? "" : "/" + requiredParams);

                    foreach(var r in routes)

                    {

                        string rt = r.RouteTemplate;

                        if (rt.EndsWith(template))

                            template = rt.Substring(0, rt.Length - requiredParams.Length);

                    }

                }

                if (!string.IsNullOrEmpty(template))

                {

                    string validateTemplate = RemoteRoutePlaceholders(template);

                    return Check(validateTemplate, template);

                }

                else

                {

                    return base.Check(member);

                }                   

            }

            return this.Problems;

        }

        private bool IsHttpVerb(string method)

        {

            bool result = false;

            if (!string.IsNullOrEmpty(method))

            {

                result = (from v in KnownVerbs

                          where string.Compare(method, v, true) == 0

                          select v).Any();

            }

            return result;

        }

        private string RemoteRoutePlaceholders(string template)

        {

            List<char> r = new List<char>();

            bool skip = false;

            foreach(var c in template.ToCharArray())

            {

                if (c == '{')

                    skip = true;

                if (!skip)

                    r.Add(c);

                if (c == '}')

                    skip = false;

            }

            string result = new string(r.ToArray());

            while (result.IndexOf("//") != -1)

            {

                result = result.Replace("//", "/");

            }

            return result;

        }

        private HttpRoute[] GetRegisteredApiRoutes(Member member)

        {

            List<HttpRoute> routeList = new List<HttpRoute>();

            var a = member.DeclaringType.ContainingAssembly().Name;

            lock (KnownRoutes)

            {

                if (!KnownRoutes.ContainsKey(a))

                {

                    // NOTE: this assumes the class name wasn't changed from one generated by VS project template

                    // TODO: make it more versatile

                    var webApiCofig = (from t in member.DeclaringType.ContainingAssembly().Types

                                       where t.ConstructorName.ToString() == "WebApiConfig"

                                       select t).FirstOrDefault();

                    var registerMethod = (from m in webApiCofig.Members

                                          where m.NodeType == NodeType.Method

                                          let tm = m as Method

                                          from p in tm.Parameters

                                          where tm.Parameters.Count == 1 && tm.Parameters[0].Type.FullName == "System.Web.Http.HttpConfiguration"

                                          select tm).FirstOrDefault();

                    var registeredRoutes = (from ms in registerMethod.Body.Statements

                                            where ms.NodeType == NodeType.Block

                                            let b = (ms as Block)

                                            from s in b.Statements

                                            where s.NodeType == NodeType.ExpressionStatement

                                            let ex = s as ExpressionStatement

                                            where ex.Expression is UnaryExpression

                                            let uex = ex.Expression as UnaryExpression

                                            where uex.Operand is Microsoft.FxCop.Sdk.NaryExpression&&  uex.Operand.Type.FullName == "System.Web.Http.Routing.IHttpRoute"

                                            select (uex.Operand as Microsoft.FxCop.Sdk.NaryExpression).Operands).ToArray();

                    foreach (var r in registeredRoutes)

                    {

                        HttpRoute route = null;

                        var operands = r.ToArray();

                        // Skip the first operand which is MethodCall

                        for (int i = 1; i < operands.Length; i++)

                        {

                            // TODO: add handling for constraints

                            switch (i)

                            {

                                //case 1:

                                //    // Get this for debugging/tracing purposes

                                //    name = operands[i].ToString();

                                //    break;

                                case 2:

                                    //template = operands[i].ToString();

                                    route = new HttpRoute(operands[i].ToString());                                 

                                    break;

                                case 3:

                                    var operandName = operands[i].Type.Members.Last().Name;

                                    foreach (var o in (operands[i] as Construct).Operands)

                                    {

                                        route.Defaults.Add(operandName.ToString(), o);

                                        //if (o.NodeType == NodeType.MemberBinding)

                                        //{

                                        //    if ((o as MemberBinding).BoundMember.FullName == "System.Web.Http.RouteParameter.Optional")

                                        //    {

                                        //        string newTemplate = template.ReplaceOrdinal("/{" + operandName.ToString() + "}", "");

                                        //        routeList.Add(newTemplate);

                                        //    }

                                        //}

                                        //else if (o.NodeType == NodeType.Literal)

                                        //{

                                        //    string newTemplate = template.ReplaceOrdinal("{" + operandName.ToString() + "}", (o as Literal).Value.ToString());

                                        //    //System.Diagnostics.Debug.WriteLine(newTemplate);

                                        //    routeList.Add(newTemplate);

                                        //}

                                    }

                                    break;

                                case 4:

                                    //handler = operands[i].ToString();

                                    break;

                            }

                        }

                        routeList.Add(route);

                    }

                    KnownRoutes.Add(a, routeList.ToArray());

                }

            }

            return KnownRoutes[a];

        }

        private string RemoveSuffix(string name, string suffix, bool caseInsensitive = true)

        {

            string result = name;

            string s = caseInsensitive ? suffix.ToLower() : suffix;

            string n = caseInsensitive ? name.ToLower() : name;

            if (n.EndsWith(s))

            {

                result = name.Substring(0, name.Length - suffix.Length);

            }

            return result;

        }

        protected WordInfo[] Words(string template)

        {

            List<WordInfo> result = new List<WordInfo>();

            var wordParser = new WordParser(template, WordParserOptions.SplitCompoundWords);

            string word = null;

            int processedIndex = 0;

            while ((word = wordParser.NextWord()) != null)

            {

                int i = template.IndexOf(word, processedIndex);

                if (i > processedIndex)

                {

                    result.Add(new WordInfo(template.Substring(processedIndex, i - processedIndex), false));

                }

                result.Add(new WordInfo(word, true));

                processedIndex = i + word.Length;

            }

            if (processedIndex < template.Length)

                result.Add(new WordInfo(template.Substring(processedIndex), false));

            return result.ToArray();

        }

        protected struct WordInfo

        {

            public string Text;

            public bool IsWord;

            public WordInfo(string text, bool isWord)

            {

                Text = text;

                IsWord = isWord;

            }

        }

    }

}

WebApiRouteShouldNotContainCapitalLetters.cs

using Microsoft.FxCop.Sdk;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace YOURCOMPANY.CodeQuality.WebAPI

{

    // Important: this implementation only checks for controller and action names, not route part registered via config.Routes.MapHttpRoute

    public class WebApiRouteShouldNotContainCapitalLetters : WebApiBaseNamingRule

    {

        public WebApiRouteShouldNotContainCapitalLetters()

            : base("WebApiRouteShouldNotContainCapitalLetters", "YOURCOMPANY.CodeQuality.Rules")

        {

        }

        public override Microsoft.FxCop.Sdk.ProblemCollection Check(string checkTemplate, string routeTemplate)

        {

            bool isValid = true;

            string validTemplate = string.Empty;

            bool precededByWord = false;

            string validWord = string.Empty;

            foreach (var w in Words(checkTemplate))

            {

                isValid& = IsValid(w.Text, precededByWord, out validWord);

                validTemplate += validWord;

                precededByWord = w.IsWord;

            }

            if (!isValid)

            {

                validTemplate = routeTemplate.Replace(checkTemplate, validTemplate);

                this.Problems.Add(new Problem(this.GetResolution(routeTemplate, validTemplate)));

            }

            return this.Problems;

        }

        private bool IsValid(string word, bool preceededByWord, out string validWord)

        {

            bool result = true;

            List<char> validChars = new List<char>();

            foreach (char c in word.ToCharArray())

            {

                if (char.IsUpper(c))

                {

                    result = false;

                    if (preceededByWord)

                        validChars.Add('-');

                    validChars.Add(char.ToLower(c));

                }

                else

                {

                    validChars.Add(c);

                }

            }

            validWord = new string(validChars.ToArray());

            return result;

        }

    }   

}

WebApiRouteShouldNotContainUnderscores.cs

using Microsoft.FxCop.Sdk;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace YOURCOMPANY.CodeQuality.WebAPI

{

    public class WebApiRouteShouldNotContainUnderscores : WebApiBaseNamingRule

    {

        public WebApiRouteShouldNotContainUnderscores()

            : base("WebApiRouteShouldNotContainUnderscores", "YOURCOMPANY.CodeQuality.Rules")

        {

        }

        public override Microsoft.FxCop.Sdk.ProblemCollection Check(string checkTemplate, string routeTemplate)

        {

            if (checkTemplate.IndexOf('_') != -1)

            {

                this.Problems.Add(new Problem(this.GetResolution(routeTemplate)));

            }

            return this.Problems;

        }

    }

}

WebApiRouteShouldUseHyphenToSeparateWords.cs

using Microsoft.FxCop.Sdk;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace YOURCOMPANY.CodeQuality.WebAPI

{

    public class WebApiRouteShouldUseHyphenToSeparateWords : WebApiBaseNamingRule

    {

        public WebApiRouteShouldUseHyphenToSeparateWords()

            : base("WebApiRouteShouldUseHyphenToSeparateWords", "YOURCOMPANY.CodeQuality.Rules")

        {

        }

        public override Microsoft.FxCop.Sdk.ProblemCollection Check(string checkTemplate, string routeTemplate)

        {

            bool isValid = true;

            string validTemplate = string.Empty;

            var words = Words(checkTemplate);

            for (int i = 0; i < words.Length; i++)

            {

                WordInfo w = words[i];

                if (i > 0 && w.IsWord && words[i - 1].IsWord)

                {

                    isValid = false;

                    validTemplate += "-";

                }

                validTemplate += w.Text.ToLower();

            }

            if (!isValid)

            {

                validTemplate = routeTemplate.Replace(checkTemplate, validTemplate);

                this.Problems.Add(new Problem(this.GetResolution(routeTemplate, validTemplate)));

            }

            return this.Problems;

        }

    }   

}

ClassFieldNamePrefixes.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Microsoft.FxCop.Sdk;

using System.Threading;

namespace YOURCOMPANY.CodeQuality

{

    public class ClassFieldNamePrefixes : BaseIntrospectionRule

    {

        public ClassFieldNamePrefixes() :

            base("ClassFieldNamePrefixes", "YOURCOMPANY.CodeQuality.Rules", typeof(ClassFieldNamePrefixes).Assembly)

        {

        }

        public override ProblemCollection Check(Member member)

        {

            if (!(member.DeclaringType is ClassNode))

                return this.Problems;

            Field fld = member as Field;

            if (fld == null)

                return this.Problems;

            if (fld.IsStatic&& !fld.Name.Name.StartsWith("s_", StringComparison.Ordinal)&&

                fld.Name.Name != "__ENCList") // Ignore edit-and-continue debugging fields

            {

                this.Problems.Add(new Problem(this.GetNamedResolution("Static", fld.Name.Name)));

            }

            else if (!fld.Name.Name.StartsWith("_", StringComparison.Ordinal)&&

                fld.Name.Name != "__ENCList"&&  fld.Name.Name != "components")

            {

                this.Problems.Add(new Problem(this.GetNamedResolution("Instance", fld.Name.Name)));

            }

            return this.Problems;

        }

    }

}

ExtensionMethods\String.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace YOURCOMPANY.CodeQuality

{

    public static class StringExtensionMethods

    {

        // Replace s1 with s2 in orig (find is case-insensitive)

        public static string ReplaceOrdinalIgnoreCase(this string orig, string s1, string s2)

        {

            string result = orig;

            int i1 = orig.ToLower().IndexOf(s1.ToLower());

            if (i1 != -1)

            {

                if (i1 == 0)

                    result = string.Empty;

                else

                    result = orig.Substring(0, i1);

                result += s2;

                int i2 = i1 + s1.Length;

                if (i2 < orig.Length)

                    result += orig.Substring(i2);

            }

            return result;

        }

    }

}

ExtensionMethods\TypeNode.cs

using Microsoft.FxCop.Sdk;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace YOURCOMPANY.CodeQuality

{

    public static class TypeExtensionMethods

    {

        public static bool IsApiController(this TypeNode t)

        {

            bool result = false;

            do

            {

                t = t.BaseType;

                if (t != null && t.Name.Name == "ApiController")

                    result = true;

            } while (t != null && result == false);

            return result;

        }

    }

}

Rules.xml

<?xml version="1.0" encoding="utf-8"?>

<Rules FriendlyName="Code Quality Rules">

  <!-- WebAPI Rules.  Check ids range 1001 - 1999-->

  <Rule TypeName="WebApiRouteShouldNotContainUnderscores" Category="YourCompany.CodeQuality" CheckId="FA1001">

    <Name>Web API route should use hyphen (-) instead of undercore (_).</Name>

    <Description>

      Do not use underscore (_) in URIs as this character is often virtually indistinguishable when the content is underlined.

    </Description>

    <Url></Url>

    <Resolution>Use hyphen instead of underscore in route '{0}' .</Resolution>

    <MessageLevel Certainty="95">Warning</MessageLevel>

    <Email></Email>

    <FixCategories>Breaking</FixCategories>

    <Owner>Microsoft, Corp.</Owner>

  </Rule>

  <Rule TypeName="WebApiRouteShouldNotContainCapitalLetters" Category="YourCompany.CodeQuality" CheckId="FA1002">

    <Name>Lowercase letters are preferred in URI paths.</Name>

    <Description>

      Web API route should use hyphen (-) to separate compound words instead of Pascal or Camel case naming convention.

    </Description>

    <Url></Url>

    <Resolution>Change from {0} route to {1} .</Resolution>

    <MessageLevel Certainty="95">Warning</MessageLevel>

    <Email></Email>

    <FixCategories>Breaking</FixCategories>

    <Owner>Microsoft, Corp.</Owner>

  </Rule>

  <Rule TypeName="WebApiRouteShouldUseHyphenToSeparateWords" Category="YourCompany.CodeQuality" CheckId="FA1003">

    <Name>Use hyphens (-) between words to improve readability of URIs</Name>

    <Description>

      Web API route should use hyphen (-) to separate compound words

    </Description>

    <Url></Url>

    <Resolution>Change from {0} route to {1} .</Resolution>

    <MessageLevel Certainty="95">Warning</MessageLevel>

    <Email></Email>

    <FixCategories>Breaking</FixCategories>

    <Owner>Microsoft, Corp.</Owner>

  </Rule>

</Rules>

I took the liberty to update it to support lambda expressions, allowing for more complex rules, e.g.

[ConditionallyRequired(typeof(YourClass), "(x) => { return x.Prop1 == 5 && x.Prop2; }")]

 Here is the resulting code:

/// <summary>

/// Make a member required under a certain condition.

/// </summary>

/// <remarks>

/// Override the attribute usage to allow multiple attributes to be applied.

/// This requires that the TypeId property be overridden on the desktop framework.

/// </remarks>

[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = true)]

public class ConditionallyRequiredAttribute : RequiredAttribute

{

    private Func<dynamic, bool> _predicate = null;

    private MemberInfo _member;

    /// <summary>

    /// The name of the member that will return the state that indicates

    /// whether or not the validated member is required.

    /// </summary>

    public string ConditionMember { get; private set; }

    /// <summary>

    /// The condition value under which this validator treats

    /// the affected member as required.

    /// </summary>

    public object RequiredCondition { get; private set; }

    /// <summary>

    /// Comma-separated list of additional members to

    /// add to validation errors.  By default, the

    /// <see cref="ConditionMember"/> is added.

    /// </summary>

    public string ErrorMembers { get; set; }

    /// <summary>

    /// Conditionally require a value, only when the specified

    /// <paramref name="conditionMember"/> is <c>true</c>.

    /// </summary>

    /// <param name="conditionMember">

    /// The member that must be <c>true</c> to require a value.

    /// </param>

    public ConditionallyRequiredAttribute(string conditionMember)

        : this(conditionMember, true) { }

    /// <summary>

    /// Conditionally require a value, only when the specified

    /// <paramref name="conditionMember"/> has a value that

    /// exactly matches the <paramref name="requiredCondition"/>.

    /// </summary>

    /// <param name="conditionMember">

    /// The member that will be evaluated to require a value.

    /// </param>

    /// <param name="requiredCondition">

    /// The value the <paramref name="conditionMember"/> must

    /// hold to require a value.

    /// </param>

    public ConditionallyRequiredAttribute(string conditionMember, object requiredCondition)

    {

        this.ConditionMember = conditionMember;

        this.RequiredCondition = requiredCondition;

        this.ErrorMembers = this.ConditionMember;

    }

    // NOTE: requires that the type being validated has a parameterized constructor!

    public ConditionallyRequiredAttribute(Type type, string predicate)

    {

        _predicate = predicate.ToFunc(type);

    }

    /// <summary>

    /// Override the base validation to only perform validation when the required

    /// condition has been met.  In the case of validation failure, augment the

    /// validation result with the <see cref="ErrorMembers"/> as an additional

    /// member names, as needed.

    /// </summary>

    /// <param name="value">The value being validated.</param>

    /// <param name="validationContext">The validation context being used.</param>

    /// <returns>

    /// <see cref="ValidationResult.Success"/> if not currently required or if satisfied,

    /// or a <see cref="ValidationResult"/> in the case of failure.

    /// </returns>

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)

    {

        ValidationResult result = ValidationResult.Success;

        if (_predicate != null)

        {

            // Add SEH

            bool condition = _predicate(validationContext.ObjectInstance);

            if (condition)

                result = base.IsValid(value, validationContext);

        }

        else if (this.DiscoverMember(validationContext.ObjectType))

        {

            object state = this.InvokeMember(validationContext.ObjectInstance);

            // We are only required if the current state

            // matches the specified condition.

            if (Object.Equals(state, this.RequiredCondition))

            {

                result = base.IsValid(value, validationContext);

                if (result != ValidationResult.Success && this.ErrorMembers != null && this.ErrorMembers.Any())

                {

                    result = new ValidationResult(result.ErrorMessage,

                       result.MemberNames.Union(this.ErrorMembers.Split(',').Select(s
=> s.Trim())));

                }

                return result;

            }

            return ValidationResult.Success;

        }

        else

        {

            throw new InvalidOperationException(

                "ConditionallyRequiredAttribute could not discover member: " + this.ConditionMember);

        }

         return result;

    }

    /// <summary>

    /// Discover the member that we will evaluate for checking our condition.

    /// </summary>

    /// <param name="objectType"></param>

    /// <returns></returns>

    private bool DiscoverMember(Type objectType)

    {

        if (this._member == null)

        {

            this._member = (from member in objectType.GetMember(this.ConditionMember).Cast<MemberInfo>()

                            where IsSupportedProperty(member) || IsSupportedMethod(member)

                            select member).SingleOrDefault();

        }

        // If we didn't find 1 exact match, indicate that we could not discover the member

        return this._member != null;

    }

    /// <summary>

    /// Determine if a <paramref name="member"/> is a

    /// method that accepts no parameters.

    /// </summary>

    /// <param name="member">The member to check.</param>

    /// <returns>

    /// <c>true</c> if the member is a parameterless method.

    /// Otherwise, <c>false</c>.

    /// </returns>

    private bool IsSupportedMethod(MemberInfo member)

    {

        if (member.MemberType != MemberTypes.Method)

        {

            return false;

        }

        MethodInfo method = (MethodInfo)member;

        return method.GetParameters().Length == 0

            && method.GetGenericArguments().Length == 0

            && method.ReturnType != typeof(void);

    }

    /// <summary>

    /// Determine if a <paramref name="member"/> is a

    /// property that has no indexer.

    /// </summary>

    /// <param name="member">The member to check.</param>

    /// <returns>

    /// <c>true</c> if the member is a non-indexed property.

    /// Otherwise, <c>false</c>.

    /// </returns>

    private bool IsSupportedProperty(MemberInfo member)

    {

        if (member.MemberType != MemberTypes.Property)

        {

            return false;

        }

        PropertyInfo property = (PropertyInfo)member;

        return property.GetIndexParameters().Length == 0;

    }

    /// <summary>

    /// Invoke the member and return its value.

    /// </summary>

    /// <param name="objectInstance">The object to invoke against.</param>

    /// <returns>The member's return value.</returns>

    private object InvokeMember(object objectInstance)

    {

        if (this._member.MemberType == MemberTypes.Method)

        {

            MethodInfo method = (MethodInfo)this._member;

            return method.Invoke(objectInstance, null);

        }

        PropertyInfo property = (PropertyInfo)this._member;

        return property.GetValue(objectInstance, null);

    }

#if
!SILVERLIGHT

    /// <summary>

    /// The desktop framework has this property and it must be

    /// overridden when allowing multiple attributes, so that

    /// attribute instances can be disambiguated based on

    /// field values.

    /// </summary>

    public override object TypeId

    {

        get { return this; }

    }

#endif

}

internal static class StringExtensions

{

    public static Func<dynamic, bool> ToFunc(this string predicate, Type type)

    {

        Func<dynamic, bool> result = null;

        // TODO: Add error checking/validation (e.g. check the the type being validated has a parameterized constructor, etc.)

        Dictionary<string, string> providerOptions = new Dictionary<string, string>();

        Version v = typeof(ConstantExpression).Assembly.GetName().Version;

        providerOptions.Add("CompilerVersion", "v" + v.Major.ToString() + "." + v.Minor.ToString());

        CSharpCodeProvider provider = new CSharpCodeProvider(providerOptions);

        CompilerResults results = provider.CompileAssemblyFromSource(

            new CompilerParameters(new[] { "System.Core.dll", "Microsoft.CSharp.dll" })

            {

                GenerateExecutable = false,

                GenerateInMemory = true

            },

            @"using System;

            using System.Linq.Expressions;

            public class ExpressionExtensions

            {

                public static Func<dynamic, bool> expr { get { return " + predicate + @"; } }

            }");

        if (results.Errors.HasErrors)

        {

            foreach (CompilerError err in results.Errors)

            {

                // TODO: Log/throw as needed

                System.Diagnostics.Debug.WriteLine(err.ErrorText);

            }

        }

        else

        {

            var asm = results.CompiledAssembly;

            var p = asm.GetType("ExpressionExtensions").GetProperty("expr", BindingFlags.Static | BindingFlags.Public);

            result = (Func<dynamic, bool>)p.GetGetMethod().Invoke(Activator.CreateInstance(type), null);

        }

        return result;

    }

}

private static MethodBase GetCallerMethod(string caller)

{

    StackTrace st = new StackTrace(2);

    return (from f in st.GetFrames() let m = f.GetMethod() where m.Name == caller select m).FirstOrDefault();

}

I used QueryThreadCycleTime API or more precise measurements

[DllImport("kernel32.dll")]

[return: MarshalAs(UnmanagedType.Bool)]

static extern bool QueryThreadCycleTime(IntPtr ThreadHandle, out ulong CycleTime);

[DllImport("kernel32.dll")]

static extern IntPtr GetCurrentThread();

and here is what I found out for my test case:

• Average CPU cycles to get StackFrame[]:  ~500,000
• Average CPU cycles for Linq query to find the calling method (which is usually near the top of the stack): ~70,000
• In comparison, a call to a local SQL server database to execute a stored procedure (getting a record based on primary key) on a very small database (narrow, well indexed tables with < 100 rows):  ~910,000

In summary, based on my tests, the cost of finding a stack frame is in the same ballpark as making a stored procedure call on a very small (sample) well indexed database residing on the same machine.

If your class and data members are marked with appropriate attributes, check to see if your class has a default constructor.  At the time of writing this post, using .NET 4.5 or 4.5.1 (I did not check other .net versions), you will get this error if your data class doesn’t have a parameterized constructor.

Here is the exception with the call stack:

Error: Cannot obtain Metadata from https://localhost:8733/Design_Time_Addresses/WcfServiceLibrary1/Service1/mex
If this is a Windows (R) Communication Foundation service to which you have
access, please check that you have enabled metadata publishing at the specified
address.  For help enabling metadata
publishing, please refer to the MSDN documentation at https://go.microsoft.com/fwlink/?LinkId=65455.WS-Metadata
Exchange Error    URI: https://localhost:8733/Design_Time_Addresses/WcfServiceLibrary1/Service1/mex    Metadata contains a reference that cannot
be resolved:
'https://localhost:8733/Design_Time_Addresses/WcfServiceLibrary1/Service1/mex'.    <?xml version="1.0" encoding="utf-16"?><Fault
xmlns="https://www.w3.org/2003/05/soap-envelope"><Code><Value>Receiver</Value><Subcode><Value
xmlns:a="https://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/dispatcher">a:InternalServiceFault</Value></Subcode></Code><Reason><Text
xml:lang="en-US">An exception was thrown in a call to a WSDL
export extension:
System.ServiceModel.Description.DataContractSerializerOperationBehavior contract:
https://tempuri.org/:IService1</Text></Reason><Detail
xmlns:s="https://www.w3.org/2003/05/soap-envelope"><ExceptionDetail
xmlns="https://schemas.datacontract.org/2004/07/System.ServiceModel"
xmlns:i="https://www.w3.org/2001/XMLSchema-instance"><HelpLink
i:nil="true"></HelpLink><InnerException><HelpLink
i:nil="true"></HelpLink><InnerException
i:nil="true"></InnerException><Message>Type
'ClassLibrary2.Phone' cannot be serialized. Consider marking it with the
DataContractAttribute attribute, and marking all of its members you want
serialized with the DataMemberAttribute attribute.  If the type is a collection, consider marking
it with the CollectionDataContractAttribute. 
See the Microsoft .NET Framework documentation for other supported
types.</Message><StackTrace>  
at
System.Runtime.Serialization.DataContract.DataContractCriticalHelper.ThrowInvalidDataContractException(String
message, Type type)   at System.Runtime.Serialization.DataContract.DataContractCriticalHelper.CreateDataContract(Int32
id, RuntimeTypeHandle typeHandle, Type type)  
at System.Runtime.Serialization.DataContract.GetDataContract(Int32 id,
RuntimeTypeHandle typeHandle, SerializationMode mode)   at System.Runtime.Serialization.DataContractSet.AddCollectionDataContract(CollectionDataContract
collectionDataContract)   at
System.Runtime.Serialization.DataContractSet.InternalAdd(XmlQualifiedName name,
DataContract dataContract)   at
System.Runtime.Serialization.DataContractSet.AddClassDataContract(ClassDataContract
classDataContract)   at
System.Runtime.Serialization.DataContractSet.InternalAdd(XmlQualifiedName name,
DataContract dataContract)   at
System.Runtime.Serialization.XsdDataContractExporter.Export(Type type)   at
System.ServiceModel.Description.MessageContractExporter.ExportType(Type type,
String partName, String operationName, XmlSchemaType&amp; xsdType)   at
System.ServiceModel.Description.DataContractSerializerMessageContractExporter.ExportBody(Int32
messageIndex, Object state)   at
System.ServiceModel.Description.MessageContractExporter.ExportMessage(Int32
messageIndex, Object state)   at
System.ServiceModel.Description.MessageContractExporter.ExportMessageContract()   at System.ServiceModel.Description.WsdlExporter.CallExtension(WsdlContractConversionContext
contractContext, IWsdlExportExtension
extension)</StackTrace><Type>System.Runtime.Serialization.InvalidDataContractException</Type></InnerException><Message>An
exception was thrown in a call to a WSDL export extension: System.ServiceModel.Description.DataContractSerializerOperationBehavior
contract: https://tempuri.org/:IService1</Message><StackTrace>   at
System.ServiceModel.Description.ServiceMetadataBehavior.MetadataExtensionInitializer.GenerateMetadata()   at
System.ServiceModel.Description.ServiceMetadataExtension.EnsureInitialized()   at
System.ServiceModel.Description.ServiceMetadataExtension.WSMexImpl.GatherMetadata(String
dialect, String identifier)   at
System.ServiceModel.Description.ServiceMetadataExtension.WSMexImpl.Get(Message
request)   at SyncInvokeGet(Object ,
Object[] , Object[] )   at
System.ServiceModel.Dispatcher.SyncMethodInvoker.Invoke(Object instance,
Object[] inputs, Object[]&amp; outputs)  
at System.ServiceModel.Dispatcher.DispatchOperationRuntime.InvokeBegin(MessageRpc&amp;
rpc)   at
System.ServiceModel.Dispatcher.ImmutableDispatchRuntime.ProcessMessage5(MessageRpc&amp;
rpc)   at System.ServiceModel.Dispatcher.ImmutableDispatchRuntime.ProcessMessage31(MessageRpc&amp;
rpc)   at
System.ServiceModel.Dispatcher.MessageRpc.Process(Boolean
isOperationContextSet)</StackTrace><Type>System.InvalidOperationException</Type></ExceptionDetail></Detail></Fault>HTTP
GET Error    URI: https://localhost:8733/Design_Time_Addresses/WcfServiceLibrary1/Service1/mex    There was an error downloading
'https://localhost:8733/Design_Time_Addresses/WcfServiceLibrary1/Service1/mex'.    The request failed with HTTP status 400:
Bad Request.

On my current project, however, there were no requirements that would direct us the DTO route, and since Entity Framework automatically creates a data contract for entities in your EDMX model, I was hoping to use the T4 generated classes as is.  However, there were two problems:

1. Using T4 generated entities as a contract in an asmx service would result in an error due to ICollection<T> used for 1->M navigation properties (e.g. Person -> Phones)
2. Entity Framework uses dynamic proxies for change tracking and lazy loading.  When returning results of an operation to the caller, serialization of navigation properties that are not loaded will trigger lazy loading resulting in a runtime exception because the DbContext is already disposed. 

You can turn off generation of the proxies by setting dbContext.Configuration.ProxyCreationEnabled to False.  However, you will lose the lazy loading functionality and will have to eagerly or explicitly load related objects.   You will also lose change tracking which may be acceptable in a service Get operation because change tracking only works on entities attached to a context, and that’s not the case once the data is returned to the caller of the service.

To deal with the aforementioned issues, you can modify the T4 template as demonstrated below.  Most of the needed work will be accomplished by the code-generated classes.  The only thing required to take advantage of this functionality is to call AsSerializable() upon returning results from your service, e.g.:

public Person GetData(int id)
{
     Person result = null;

     using (var ctx = new ModelEntities())
     {
         result = (from e in ctx.Person.Include("Phones") where e.PersonID == id select e).FirstOrDefault();
     }

     return result.AsSerializable();
} 


Model.tt file
Changes highlighted

<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ include file="EF6.Utility.CS.ttinclude"#><#@
 output extension=".cs"#><#

const string inputFile = @"..\DataAccess\Model1.edmx";
var textTransform = DynamicTextTransformation.Create(this);
var code = new CodeGenerationTools(this);
var ef = new MetadataTools(this);
var typeMapper = new TypeMapper(code, ef, textTransform.Errors);
var fileManager = EntityFrameworkTemplateFileManager.Create(this);
var itemCollection = new EdmMetadataLoader(textTransform.Host, textTransform.Errors).CreateEdmItemCollection(inputFile);
var codeStringGenerator = new CodeStringGenerator(code, typeMapper, ef);

if (!typeMapper.VerifyCaseInsensitiveTypeUniqueness(typeMapper.GetAllGlobalItems(itemCollection), inputFile))
{
    return string.Empty;
}

WriteHeader(codeStringGenerator, fileManager);

fileManager.StartNewFile("Serializable.cs");
BeginNamespace(code);
SerializableObject();
EndNamespace(code);

foreach (var entity in typeMapper.GetItemsToGenerate<EntityType>(itemCollection))
{
    fileManager.StartNewFile(entity.Name + ".cs");
    BeginNamespace(code);
#>
<#=codeStringGenerator.UsingDirectives(inHeader: false)#>
<#=codeStringGenerator.EntityClassOpening(entity)#>
{
<#
    var propertiesWithDefaultValues = typeMapper.GetPropertiesWithDefaultValues(entity);
    var collectionNavigationProperties = typeMapper.GetCollectionNavigationProperties(entity);
    var complexProperties = typeMapper.GetComplexProperties(entity);

    //if (propertiesWithDefaultValues.Any() || collectionNavigationProperties.Any() || complexProperties.Any())
    {
#>
    public <#=code.Escape(entity)#>()
    {
<#
        foreach (var edmProperty in propertiesWithDefaultValues)
        {
#>
        this.<#=code.Escape(edmProperty)#> = <#=typeMapper.CreateLiteral(edmProperty.DefaultValue)#>;
<#
        }

        foreach (var navigationProperty in collectionNavigationProperties)
        {
#>
  this.<#=code.Escape(navigationProperty)#> = new List<<#=typeMapper.GetTypeName(navigationProperty.ToEndMember.GetEntityType())#>>();
<#
        }

        foreach (var complexProperty in complexProperties)
        {
#>
        this.<#=code.Escape(complexProperty)#> = new <#=typeMapper.GetTypeName(complexProperty.TypeUsage)#>();
<#
        }
#>
    }

 private <#=code.Escape(entity)#>(<#=code.Escape(entity)#> obj) : base(obj, null) { }
 private <#=code.Escape(entity)#>(<#=code.Escape(entity)#> obj, Dictionary<Type, object> createdTypes) : base(obj, createdTypes) { }
<# 

    }

    var simpleProperties = typeMapper.GetSimpleProperties(entity);
    if (simpleProperties.Any())
    {
        foreach (var edmProperty in simpleProperties)
        {
#>
    <#=codeStringGenerator.Property(edmProperty)#>
<#
        }
    }

    if (complexProperties.Any())
    {
#>

<#
        foreach(var complexProperty in complexProperties)
        {
#>
    <#=codeStringGenerator.Property(complexProperty)#>
<#
        }
    }

    var navigationProperties = typeMapper.GetNavigationProperties(entity);
    if (navigationProperties.Any())
    {
#>

<#
        foreach (var navigationProperty in navigationProperties)
        {
#>
    <#=codeStringGenerator.NavigationProperty(navigationProperty)#>
<#
        }
    }
#>
}
<#
    EndNamespace(code);
}

foreach (var complex in typeMapper.GetItemsToGenerate<ComplexType>(itemCollection))
{
    fileManager.StartNewFile(complex.Name + ".cs");
    BeginNamespace(code);
#>
<#=codeStringGenerator.UsingDirectives(inHeader: false, includeCollections: false)#>
<#=Accessibility.ForType(complex)#> partial class <#=code.Escape(complex)#>  
{
<#
    var complexProperties = typeMapper.GetComplexProperties(complex);
    var propertiesWithDefaultValues = typeMapper.GetPropertiesWithDefaultValues(complex);

    if (propertiesWithDefaultValues.Any() || complexProperties.Any())
    {
#>
    public <#=code.Escape(complex)#>()
    {
<#
        foreach (var edmProperty in propertiesWithDefaultValues)
        {
#>
        this.<#=code.Escape(edmProperty)#> = <#=typeMapper.CreateLiteral(edmProperty.DefaultValue)#>;
<#
        }

        foreach (var complexProperty in complexProperties)
        {
#>
        this.<#=code.Escape(complexProperty)#> = new <#=typeMapper.GetTypeName(complexProperty.TypeUsage)#>();
<#
        }
#>
    }

<#
    }

    var simpleProperties = typeMapper.GetSimpleProperties(complex);
    if (simpleProperties.Any())
    {
        foreach(var edmProperty in simpleProperties)
        {
#>
    <#=codeStringGenerator.Property(edmProperty)#>
<#
        }
    }

    if (complexProperties.Any())
    {
#>

<#
        foreach(var edmProperty in complexProperties)
        {
#>
    <#=codeStringGenerator.Property(edmProperty)#>
<#
        }
    }
#>
}
<#
    EndNamespace(code);
}

foreach (var enumType in typeMapper.GetEnumItemsToGenerate(itemCollection))
{
    fileManager.StartNewFile(enumType.Name + ".cs");
    BeginNamespace(code);
#>
<#=codeStringGenerator.UsingDirectives(inHeader: false, includeCollections: false)#>
<#
    if (typeMapper.EnumIsFlags(enumType))
    {
#>
[Flags]
<#
    }
#>
<#=codeStringGenerator.EnumOpening(enumType)#>
{
<#
    var foundOne = false;
   
    foreach (MetadataItem member in typeMapper.GetEnumMembers(enumType))
    {
        foundOne = true;
#>
    <#=code.Escape(typeMapper.GetEnumMemberName(member))#> = <#=typeMapper.GetEnumMemberValue(member)#>,
<#
    }

    if (foundOne)
    {
        this.GenerationEnvironment.Remove(this.GenerationEnvironment.Length - 3, 1);
    }
#>
}
<#
    EndNamespace(code);
}

fileManager.Process();

#>
<#+

public void WriteHeader(CodeStringGenerator codeStringGenerator, EntityFrameworkTemplateFileManager fileManager)
{
    fileManager.StartHeader();
#>
//------------------------------------------------------------------------------
// <auto-generated>
// <#=CodeGenerationTools.GetResourceString("Template_GeneratedCodeCommentLine1")#>
//
// <#=CodeGenerationTools.GetResourceString("Template_GeneratedCodeCommentLine2")#>
// <#=CodeGenerationTools.GetResourceString("Template_GeneratedCodeCommentLine3")#>
// </auto-generated>
//------------------------------------------------------------------------------
<#=codeStringGenerator.UsingDirectives(inHeader: true)#>
<#+
    fileManager.EndBlock();
}

public void BeginNamespace(CodeGenerationTools code)
{
    var codeNamespace = code.VsNamespaceSuggestion();
    if (!String.IsNullOrEmpty(codeNamespace))
    {
#>
namespace <#=code.EscapeNamespace(codeNamespace)#>
{
<#+
        PushIndent("    ");
    }
}

public void EndNamespace(CodeGenerationTools code)
{
    if (!String.IsNullOrEmpty(code.VsNamespaceSuggestion()))
    {
        PopIndent();
#>
}
<#+
    }
}

public void SerializableObject()
{
#>
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.Serialization;

[DataContract]
public abstract class SerializableObject<T> where T : class
{
    [NonSerialized]
    private Dictionary<Type, object> CreatedTypes = null;

    [DataMember]
    public T OriginalValues { get; private set; }

    public T AsSerializable()
    {       
  T origValues = CreateInstance(typeof(T), new object[] { this }) as T;
  (origValues as SerializableObject<T>).OriginalValues = null;

  T result = CreateInstance(typeof(T), new object[] { this }) as T;
  (result as SerializableObject<T>).OriginalValues = origValues;

  return result;
    }

    public SerializableObject() { }

    protected SerializableObject(T o, Dictionary<Type, object> createdTypes)
    {
        this.CreatedTypes = createdTypes == null ? new Dictionary<Type, object>() : createdTypes;

        if (createdTypes == null)
            this.CreatedTypes.Add(this.GetType(), this);

        foreach (var f in this.GetType().GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance))
        {
            System.Diagnostics.Debug.WriteLine(f.Name);
            object fv = f.GetValue(o);
            if (fv != null && fv.GetType().IsGenericType)
            {
                Type t = fv.GetType().GetGenericTypeDefinition();
                Type fieldType = t.MakeGenericType(fv.GetType().GenericTypeArguments);
                IList items = null;

                if (fv is IEnumerable)
                {
                    Type itemType = null;
                    Type itemsType = typeof(List<>).GetGenericTypeDefinition();

                    foreach (var i in fv as IEnumerable)
                    {
                        if (itemType == null)
                        {
                            // TODO: Remove reliance on the string EntityProxyModule
                            if (i.GetType().Module.ScopeName == "EntityProxyModule")
                                itemType = i.GetType().BaseType;
                            else
                                itemType = i.GetType();

                            items = Activator.CreateInstance(itemsType.MakeGenericType(itemType)) as IList;
                        }

                        object item = CreateInstance(itemType, new object[] { i });
                        items.Add(item);
                    }

                    dynamic v = CreateInstance(fieldType, new object[] { items });
                    f.SetValue(this, v);

                }
                else
                {
                    f.SetValue(this, CreateInstance(fieldType, new object[] { fv }));
                }
            }
            else
            {
                if (fv != null)
                {
                    // TODO: Remove reliance on the string EntityProxyModule
                    if (fv.GetType().Module.ScopeName == "EntityProxyModule")
                    {
                        fv = CreateInstance(fv.GetType().BaseType, new object[] { fv }, true);
                    }
                }
                f.SetValue(this, fv);
            }
        }
    }

    private object CreateInstance(Type t, object[] args, bool cache = false)
    {
        object result = null;

        if (this.CreatedTypes != null && this.CreatedTypes.ContainsKey(t))
        {
            // Return null to avoid circular references leading to runtime exceptions like
            /*
                An exception of type 'Microsoft.CSharp.RuntimeBinder.RuntimeBinderException' occurred in System.Core.dll but was not handled in user code
                Additional information: The best overloaded method match for 'System.Collections.Generic.HashSet<ClassLibrary2.Phone>.Add(ClassLibrary2.Phone)' has some invalid arguments

                    at CallSite.Target(Closure , CallSite , Object , Object )
                    at System.Dynamic.UpdateDelegates.UpdateAndExecuteVoid2[T0,T1](CallSite site, T0 arg0, T1 arg1)
                    at ClassLibrary2.SerializableObject`1..ctor(T o, Dictionary`2 createdTypes) in c:\Temp\xx\ClassLibrary2\Class1.cs:line 60
                    at ClassLibrary2.SerializableObject`1..ctor(T o) in c:\Temp\xx\ClassLibrary2\Class1.cs:line 20
                    at ClassLibrary2.Employee..ctor(Employee e) in c:\Temp\xx\ClassLibrary2\Class1.cs:line 122
                    at WcfServiceLibrary1.Service1.GetData(Int32 value) in c:\Temp\xx\WcfServiceLibrary1\Service1.cs:line 24
                    at SyncInvokeGetData(Object , Object[] , Object[] )
                    at System.ServiceModel.Dispatcher.SyncMethodInvoker.Invoke(Object instance, Object[] inputs, Object[]& outputs)
                    at System.ServiceModel.Dispatcher.DispatchOperationRuntime.InvokeBegin(MessageRpc& rpc)

            */
            // result = this.CreatedTypes[t];
            result = null;
        }
        else
        {
            Type gt = typeof(SerializableObject<>).GetGenericTypeDefinition();

            if (t.IsSubclassOf(gt.MakeGenericType(t)))
            {
                List<object> newArgs = new List<object>();
                newArgs.AddRange(args);
                newArgs.Add(this.CreatedTypes);

                var ctor = t.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null,
                    new Type[] { t, typeof(Dictionary<Type, object>) }, null);
                System.Diagnostics.Debug.Assert(ctor != null);
                result = ctor.Invoke(newArgs.ToArray());
            }
            else
            {
                if (args[0] == null)
                    result = Activator.CreateInstance(t);
                else
                    result = Activator.CreateInstance(t, args);
            }

            if (cache)
                this.CreatedTypes.Add(t, result);
        }

        return result;
 }
}
 <#+

}

public const string TemplateId = "CSharp_DbContext_Types_EF6";

public class CodeStringGenerator
{
    private readonly CodeGenerationTools _code;
    private readonly TypeMapper _typeMapper;
    private readonly MetadataTools _ef;

    public CodeStringGenerator(CodeGenerationTools code, TypeMapper typeMapper, MetadataTools ef)
    {
        ArgumentNotNull(code, "code");
        ArgumentNotNull(typeMapper, "typeMapper");
        ArgumentNotNull(ef, "ef");

        _code = code;
        _typeMapper = typeMapper;
        _ef = ef;
    }

    public string Property(EdmProperty edmProperty)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1} {2} {{ {3}get; {4}set; }}",
            Accessibility.ForProperty(edmProperty),
            _typeMapper.GetTypeName(edmProperty.TypeUsage),
            _code.Escape(edmProperty),
            _code.SpaceAfter(Accessibility.ForGetter(edmProperty)),
            _code.SpaceAfter(Accessibility.ForSetter(edmProperty)));
    }

    public string NavigationProperty(NavigationProperty navProp)
    {
        var endType = _typeMapper.GetTypeName(navProp.ToEndMember.GetEntityType());
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1} {2} {{ {3}get; {4}set; }}",
            AccessibilityAndVirtual(Accessibility.ForNavigationProperty(navProp)),
   navProp.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many ? ("List<" + endType + ">") : endType,
            _code.Escape(navProp),
            _code.SpaceAfter(Accessibility.ForGetter(navProp)),
            _code.SpaceAfter(Accessibility.ForSetter(navProp)));
    }
   
    public string AccessibilityAndVirtual(string accessibility)
    {
        return accessibility + (accessibility != "private" ? " virtual" : "");
    }
   
    public string EntityClassOpening(EntityType entity)
    {
  var baseType = entity.BaseType != null ? _typeMapper.GetTypeName(entity.BaseType)
   : "SerializableObject<" +  _code.Escape(entity) + ">";

        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1}partial class {2}{3}",
            Accessibility.ForType(entity),
            _code.SpaceAfter(_code.AbstractOption(entity)),
            _code.Escape(entity),
            _code.StringBefore(" : ", baseType ));
    }
   
    public string EnumOpening(SimpleType enumType)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} enum {1} : {2}",
            Accessibility.ForType(enumType),
            _code.Escape(enumType),
            _code.Escape(_typeMapper.UnderlyingClrType(enumType)));
        }
   
    public void WriteFunctionParameters(EdmFunction edmFunction, Action<string, string, string, string> writeParameter)
    {
        var parameters = FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);
        foreach (var parameter in parameters.Where(p => p.NeedsLocalVariable))
        {
            var isNotNull = parameter.IsNullableOfT ? parameter.FunctionParameterName + ".HasValue" : parameter.FunctionParameterName + " != null";
            var notNullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", " + parameter.FunctionParameterName + ")";
            var nullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", typeof(" + TypeMapper.FixNamespaces(parameter.RawClrTypeName) + "))";
            writeParameter(parameter.LocalVariableName, isNotNull, notNullInit, nullInit);
        }
    }
   
    public string ComposableFunctionMethod(EdmFunction edmFunction, string modelNamespace)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
       
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} IQueryable<{1}> {2}({3})",
            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),
            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),
            _code.Escape(edmFunction),
            string.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray()));
    }
   
    public string ComposableCreateQuery(EdmFunction edmFunction, string modelNamespace)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
       
        return string.Format(
            CultureInfo.InvariantCulture,
            "return ((IObjectContextAdapter)this).ObjectContext.CreateQuery<{0}>(\"[{1}].[{2}]({3})\"{4});",
            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),
            edmFunction.NamespaceName,
            edmFunction.Name,
            string.Join(", ", parameters.Select(p => "@" + p.EsqlParameterName).ToArray()),
            _code.StringBefore(", ", string.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray())));
    }
   
    public string FunctionMethod(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        var returnType = _typeMapper.GetReturnType(edmFunction);

        var paramList = String.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray());
        if (includeMergeOption)
        {
            paramList = _code.StringAfter(paramList, ", ") + "MergeOption mergeOption";
        }

        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} {1} {2}({3})",
            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),
            returnType == null ? "int" : "ObjectResult<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",
            _code.Escape(edmFunction),
            paramList);
    }
   
    public string ExecuteFunction(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)
    {
        var parameters = _typeMapper.GetParameters(edmFunction);
        var returnType = _typeMapper.GetReturnType(edmFunction);

        var callParams = _code.StringBefore(", ", String.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray()));
        if (includeMergeOption)
        {
            callParams = ", mergeOption" + callParams;
        }
       
        return string.Format(
            CultureInfo.InvariantCulture,
            "return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction{0}(\"{1}\"{2});",
            returnType == null ? "" : "<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",
            edmFunction.Name,
            callParams);
    }
   
    public string DbSet(EntitySet entitySet)
    {
        return string.Format(
            CultureInfo.InvariantCulture,
            "{0} virtual DbSet<{1}> {2} {{ get; set; }}",
            Accessibility.ForReadOnlyProperty(entitySet),
            _typeMapper.GetTypeName(entitySet.ElementType),
            _code.Escape(entitySet));
    }

    public string UsingDirectives(bool inHeader, bool includeCollections = true)
    {
        return inHeader == string.IsNullOrEmpty(_code.VsNamespaceSuggestion())
            ? string.Format(
                CultureInfo.InvariantCulture,
                "{0}using System;{1}" +
                "{2}",
                inHeader ? Environment.NewLine : "",
                includeCollections ? (Environment.NewLine + "using System.Collections.Generic;") : "",
                inHeader ? "" : Environment.NewLine)
            : "";
    } 

}

public class TypeMapper
{
    private const string ExternalTypeNameAttributeName = @"https://schemas.microsoft.com/ado/2006/04/codegeneration:ExternalTypeName";

    private readonly System.Collections.IList _errors;
    private readonly CodeGenerationTools _code;
    private readonly MetadataTools _ef;

    public TypeMapper(CodeGenerationTools code, MetadataTools ef, System.Collections.IList errors)
    {
        ArgumentNotNull(code, "code");
        ArgumentNotNull(ef, "ef");
        ArgumentNotNull(errors, "errors");

        _code = code;
        _ef = ef;
        _errors = errors;
    }

    public static string FixNamespaces(string typeName)
    {
        return typeName.Replace("System.Data.Spatial.", "System.Data.Entity.Spatial.");
    }

    public string GetTypeName(TypeUsage typeUsage)
    {
        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace: null);
    }

    public string GetTypeName(EdmType edmType)
    {
        return GetTypeName(edmType, isNullable: null, modelNamespace: null);
    }

    public string GetTypeName(TypeUsage typeUsage, string modelNamespace)
    {
        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace);
    }

    public string GetTypeName(EdmType edmType, string modelNamespace)
    {
        return GetTypeName(edmType, isNullable: null, modelNamespace: modelNamespace);
    }

    public string GetTypeName(EdmType edmType, bool? isNullable, string modelNamespace)
    {
        if (edmType == null)
        {
            return null;
        }

        var collectionType = edmType as CollectionType;
        if (collectionType != null)
        {
            return String.Format(CultureInfo.InvariantCulture, "List<{0}>", GetTypeName(collectionType.TypeUsage, modelNamespace));
        }

        var typeName = _code.Escape(edmType.MetadataProperties
                                .Where(p => p.Name == ExternalTypeNameAttributeName)
                                .Select(p => (string)p.Value)
                                .FirstOrDefault())
            ?? (modelNamespace != null && edmType.NamespaceName != modelNamespace ?
                _code.CreateFullName(_code.EscapeNamespace(edmType.NamespaceName), _code.Escape(edmType)) :
                _code.Escape(edmType));

        if (edmType is StructuralType)
        {
            return typeName;
        }

        if (edmType is SimpleType)
        {
            var clrType = UnderlyingClrType(edmType);
            if (!IsEnumType(edmType))
            {
                typeName = _code.Escape(clrType);
            }

            typeName = FixNamespaces(typeName);

            return clrType.IsValueType && isNullable == true ?
                String.Format(CultureInfo.InvariantCulture, "Nullable<{0}>", typeName) :
                typeName;
        }

        throw new ArgumentException("edmType");
    }
   
    public Type UnderlyingClrType(EdmType edmType)
    {
        ArgumentNotNull(edmType, "edmType");

        var primitiveType = edmType as PrimitiveType;
        if (primitiveType != null)
        {
            return primitiveType.ClrEquivalentType;
        }

        if (IsEnumType(edmType))
        {
            return GetEnumUnderlyingType(edmType).ClrEquivalentType;
        }

        return typeof(object);
    }
   
    public object GetEnumMemberValue(MetadataItem enumMember)
    {
        ArgumentNotNull(enumMember, "enumMember");
       
        var valueProperty = enumMember.GetType().GetProperty("Value");
        return valueProperty == null ? null : valueProperty.GetValue(enumMember, null);
    }
   
    public string GetEnumMemberName(MetadataItem enumMember)
    {
        ArgumentNotNull(enumMember, "enumMember");
       
        var nameProperty = enumMember.GetType().GetProperty("Name");
        return nameProperty == null ? null : (string)nameProperty.GetValue(enumMember, null);
    }

    public System.Collections.IEnumerable GetEnumMembers(EdmType enumType)
    {
        ArgumentNotNull(enumType, "enumType");

        var membersProperty = enumType.GetType().GetProperty("Members");
        return membersProperty != null
            ? (System.Collections.IEnumerable)membersProperty.GetValue(enumType, null)
            : Enumerable.Empty<MetadataItem>();
    }
   
    public bool EnumIsFlags(EdmType enumType)
    {
        ArgumentNotNull(enumType, "enumType");
       
        var isFlagsProperty = enumType.GetType().GetProperty("IsFlags");
        return isFlagsProperty != null && (bool)isFlagsProperty.GetValue(enumType, null);
    }

    public bool IsEnumType(GlobalItem edmType)
    {
        ArgumentNotNull(edmType, "edmType");

        return edmType.GetType().Name == "EnumType";
    }

    public PrimitiveType GetEnumUnderlyingType(EdmType enumType)
    {
        ArgumentNotNull(enumType, "enumType");

        return (PrimitiveType)enumType.GetType().GetProperty("UnderlyingType").GetValue(enumType, null);
    }

    public string CreateLiteral(object value)
    {
        if (value == null || value.GetType() != typeof(TimeSpan))
        {
            return _code.CreateLiteral(value);
        }

        return string.Format(CultureInfo.InvariantCulture, "new TimeSpan({0})", ((TimeSpan)value).Ticks);
    }
   
    public bool VerifyCaseInsensitiveTypeUniqueness(IEnumerable<string> types, string sourceFile)
    {
        ArgumentNotNull(types, "types");
        ArgumentNotNull(sourceFile, "sourceFile");
       
        var hash = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
        if (types.Any(item => !hash.Add(item)))
        {
            _errors.Add(
                new CompilerError(sourceFile, -1, -1, "6023",
                    String.Format(CultureInfo.CurrentCulture, CodeGenerationTools.GetResourceString("Template_CaseInsensitiveTypeConflict"))));
            return false;
        }
        return true;
    }
   
    public IEnumerable<SimpleType> GetEnumItemsToGenerate(IEnumerable<GlobalItem> itemCollection)
    {
        return GetItemsToGenerate<SimpleType>(itemCollection)
            .Where(e => IsEnumType(e));
    }
   
    public IEnumerable<T> GetItemsToGenerate<T>(IEnumerable<GlobalItem> itemCollection) where T: EdmType
    {
        return itemCollection
            .OfType<T>()
            .Where(i => !i.MetadataProperties.Any(p => p.Name == ExternalTypeNameAttributeName))
            .OrderBy(i => i.Name);
    }

    public IEnumerable<string> GetAllGlobalItems(IEnumerable<GlobalItem> itemCollection)
    {
        return itemCollection
            .Where(i => i is EntityType || i is ComplexType || i is EntityContainer || IsEnumType(i))
            .Select(g => GetGlobalItemName(g));
    }

    public string GetGlobalItemName(GlobalItem item)
    {
        if (item is EdmType)
        {
            return ((EdmType)item).Name;
        }
        else
        {
            return ((EntityContainer)item).Name;
        }
    }

    public IEnumerable<EdmProperty> GetSimpleProperties(EntityType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);
    }
   
    public IEnumerable<EdmProperty> GetSimpleProperties(ComplexType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);
    }
   
    public IEnumerable<EdmProperty> GetComplexProperties(EntityType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);
    }
   
    public IEnumerable<EdmProperty> GetComplexProperties(ComplexType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);
    }

    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(EntityType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);
    }
   
    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(ComplexType type)
    {
        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);
    }

    public IEnumerable<NavigationProperty> GetNavigationProperties(EntityType type)
    {
        return type.NavigationProperties.Where(np => np.DeclaringType == type);
    }
   
    public IEnumerable<NavigationProperty> GetCollectionNavigationProperties(EntityType type)
    {
        return type.NavigationProperties.Where(np => np.DeclaringType == type && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many);
    }
   
    public FunctionParameter GetReturnParameter(EdmFunction edmFunction)
    {
        ArgumentNotNull(edmFunction, "edmFunction");

        var returnParamsProperty = edmFunction.GetType().GetProperty("ReturnParameters");
        return returnParamsProperty == null
            ? edmFunction.ReturnParameter
            : ((IEnumerable<FunctionParameter>)returnParamsProperty.GetValue(edmFunction, null)).FirstOrDefault();
    }

    public bool IsComposable(EdmFunction edmFunction)
    {
        ArgumentNotNull(edmFunction, "edmFunction");

        var isComposableProperty = edmFunction.GetType().GetProperty("IsComposableAttribute");
        return isComposableProperty != null && (bool)isComposableProperty.GetValue(edmFunction, null);
    }

    public IEnumerable<FunctionImportParameter> GetParameters(EdmFunction edmFunction)
    {
        return FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);
    }

    public TypeUsage GetReturnType(EdmFunction edmFunction)
    {
        var returnParam = GetReturnParameter(edmFunction);
        return returnParam == null ? null : _ef.GetElementType(returnParam.TypeUsage);
    }
   
    public bool GenerateMergeOptionFunction(EdmFunction edmFunction, bool includeMergeOption)
    {
        var returnType = GetReturnType(edmFunction);
        return !includeMergeOption && returnType != null && returnType.EdmType.BuiltInTypeKind == BuiltInTypeKind.EntityType;
    }
}

public static void ArgumentNotNull<T>(T arg, string name) where T : class
{
    if (arg == null)
    {
        throw new ArgumentNullException(name);
    }
}
#>

Number of
concatenations Time taken in ms
-------------------------------------------
2,000           2
5,000           12
10,000          46
100,000         14,631

- Getting data elements from an array results in about the same performance in small numbers (up to 10,000), but at 100,000, the performance is almost 70% slower

- Doing 10,000 concatenations with string.Format with a format string taking 1,000 elements at a time (adding a loop to execute logic 10 time, so we end up with 10,000 concatenations) takes 18 ms (compare to 46 when doing appending one string at a time via traditional += type of concatenation)

- When Format string is only 100 elements and looping 100 times, the time taken for 10,000 concatenations drops down to under 3 ms.

The performance numbers change slightly, but the ratio stays about the same when I add GC.Collect call.
Ok, so that’s for large number of strings…  What about just a few concatenations, like putting together an address from its parts?
Running Concat function vs. Format function below 10,000 times resulted in roughly the same performance – about 3-4 ms total time taken.   Increasing the loop count to 10,000,000 resulted in 2,831 for 6 string concatenated via Concat function vs. 3,380 ms for same number of concatenations via Format.
Interestingly, when concatenating only two or three strings (e.g. person’s first and last name), the concatenation took almost 3 times less time than using the Format function -- 546 ms for 10,000,000 concatenations of 2 strings with Concat vs. 1501 via Format.
private static string Concat(string s1, string s2, string s3, string s4, string s5, string s6)
{
    return s1 + "\r\n" + s2 + "\r\n" +s3 + "\r\n" + s4 + ", " + s5 + " " + s6;
}
private static string Format(string s1, string s2, string s3, string s4, string s5, string s6)
{
    return string.Format("{0}\r\n{1}\r\n{2}\r\n{3}, {4} {5}", s1, s2, s3, s4, s5, s6);
}

So, what’s the significance of all of this?  In my opinion, when putting together small number of strings, e.g. person’s name, address, etc., even if you’re dealing with dozens and a few hundred strings, from performance point of view, the difference is negligible.  I used to favor string.Format because of the type conversion, but it you have a mismatch between the number of arguments in the format string’s and those passed in, you’ll end up with a runtime error. Nowadays, the framework properly handle concatenating a number, a string and a null, e.g.
int number = 5;
string nullString = null;
string result = number + nullString + "abc";

will give you "5abc".   So, string concatenations (in reasonable numbers) don’t appear to be such an evil…  However, with large number of concatenations you should evaluate your case and consider whether the performance hit, as well as the CPU utilization, warrant a different way of handing your data.

To make this work, I need to create instance of NetworkCredential class and pass it on through the client proxy prior to making any calls to the service, e.g.

((System.ServiceModel.ClientBase<YourNamesapce.IYourService>)(client)).ClientCredentials.Windows.ClientCredential = new System.Net.NetworkCredential("login", "password", "domain");

Since the project is going to be used by domain users, and the situation described above won’t be an issue, I’m one of the few consultants that have to deal with this, and, of course, putting the line above in the code is not an option.  As an alternative, and, in my opinion, a more elegant solution, I wrote custom endpoint behavior, so, the only two things I need to do now is:

1.  Make sure my WCF custom behavior assembly is in the bin file of the client
2.  Update client side configuration file as follows:

      a)     Add behaviorExtension element

    <extensions>

        <behaviorExtensions>

            <add name="windowsClientCredentials" type="WCFExtensions.WindowsClientCredentialsConfig, WCFExtensions, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />

        </behaviorExtensions>

    </extensions>

      b). Add windowsClientCredentials element to the behavior used by the endpoint, e.g.

    <behaviors>

        <endpointBehaviors>

            <behavior name="NewBehavior0">

                <windowsClientCredentials user="x" password="y" domain="z" />

            </behavior>

        </endpointBehaviors>

    </behaviors>

NOTE:  I have not added encryption of the credentials in the config file.  If you choose to use it in an enterprise application, I strongly suggest you secure the login settings.

Below is the code for the custom behavior endpoint (just create a Windows class library project, add a class with the code below and compile.

using System;

using System.Configuration;

using System.Linq;

using System.ServiceModel.Configuration;

using System.ServiceModel.Description;

using System.ServiceModel.Dispatcher;

namespace WCFExtensions

{

    public class WindowsClientCredentialsConfig : BehaviorExtensionElement

    {

        protected override object CreateBehavior()

        {

            return new WindowsClientCredentialsBehavior(this.User, this.Password, this.Domain);

        }

        public override Type BehaviorType

        {

            get { return typeof(WindowsClientCredentialsBehavior); }

        }

        [ConfigurationProperty("user", IsRequired = true)]

        public string User

        {

            get { return (string)this["user"]; }

            set { this["user"] = value; }

        }

        [ConfigurationProperty("password", IsRequired = true)]

        public string Password

        {

            get { return (string)this["password"]; }

            set { this["password"] = value; }

        }

        [ConfigurationProperty("domain", IsRequired = true)]

        public string Domain

        {

            get { return (string)this["domain"]; }

            set { this["domain"] = value; }

        }

    }

    public class WindowsClientCredentialsBehavior : IEndpointBehavior

    {

        private string _user, _password, _domain;

        public WindowsClientCredentialsBehavior(string user, string password, string domain)

        {

            _user = user;

            _password = password;

            _domain = domain;

        }

        public void AddBindingParameters(ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)

        {

            ClientCredentials clientCredentials = (from item in bindingParameters where item is ClientCredentials select item).FirstOrDefault() as ClientCredentials;

            if (clientCredentials == null)

            {

                clientCredentials = new ClientCredentials();

                bindingParameters.Add(clientCredentials);

            }

            clientCredentials.Windows.ClientCredential = new System.Net.NetworkCredential(_user, _password, _domain);

        }

        public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)

        {

        }

        public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)

        {

        }

        public void Validate(ServiceEndpoint endpoint)

        {

            ClientCredentials clientCredentials = (from item in endpoint.Behaviors where item is ClientCredentials select item).FirstOrDefault() as ClientCredentials;

            if (clientCredentials != null)

                endpoint.Behaviors.Remove(clientCredentials);

        }

    }

}