Nesterovsky bros - .NET

Error handling in WCF based web applications

Arthur Nesterovsky — Mon, 13 May 2013 23:09:02 GMT

Although WCF REST service + JSON is outdated comparing to Web API, there are yet a lot of such solutions (and probably will appear new ones) that use such "old" technology.

One of the crucial points of any web application is an error handler that allows gracefully resolve server-side exceptions and routes them as JSON objects to the client for further processing. There are dozen approachesin Internet that solve this issue (e.g. http://blog.manglar.com/how-to-provide-custom-json-exceptions-from-as-wcf-service/), but there is no one that demonstrates error handling ot the client-side. We realize that it's impossible to write something general that suits for every web application, but we'd like to show a client-side error handler that utilizes JSON and KendoUI.

On our opinion, the successfull error handler must display an understandable error message on one hand, and on the other hand it has to provide technical info for developers in order to investigate the exception reason (and to fix it, if need):

You may download demo project here. It contains three crucial parts:

A server-side error handler that catches all exceptions and serializes them as JSON objects (see /Code/JsonErrorHandler.cs and /Code/JsonWebHttpBehaviour.cs).
An error dialog that's based on user-control defined in previous articles (see /scripts/controls/error.js, /scripts/controls/error.resources.js and /scripts/templates/error.tmpl.html).
A client-side error handler that displays errors in user-friendly's manner (see /scripts/api/api.js, method defaultErrorHandler()).

Of course this is only a draft solution, but it defines a direction for further customizations in your web applications.

How To: Load KendoUI Templates from External Files

Vladimir Nesterovsky — Sun, 06 Jan 2013 19:43:19 GMT

Kendo UI Docs contains an article "How To: Load Templates from External Files", where authors review two way of dealing with Kendo UI templates.

While using Kendo UI we have found our own answer to: where will the Kendo UI templates be defined and maintained?

In our .NET project we have decided to keep templates separately, and to store them under the "templates" folder. Those templates are in fact include html, head, and stylesheet links. This is to help us to present those tempates in the design view.

In our scripts folder, we have defined a small text transformation template: "templates.tt", which produces "templates.js" file. This template takes body contents of each "*.tmpl.html" file from "templates" folder and builds string of the form:

document.write('<script id="footer-template" type="text/x-kendo-template">...</script><script id="row-template" type="text/x-kendo-template">...</script>');

In our page that uses templates, we include "templates.js":

<!DOCTYPE html> <html> <head> <script src="scripts/templates.js"></script> ...

Thus, we have:

clean separation of templates and page content;
automatically generated templates include file.

WebTemplates.zip contains a web project demonstrating our technique. "templates.tt" is text template transformation used in the project.

StreamResource

Vladimir Nesterovsky — Tue, 20 Nov 2012 07:01:57 GMT

Our goal is to generate reports in streaming mode.

At some point we need to deal with data streams (e.g. xml streams for xslt transformations). Often a nature of report demands several passes through the data. To increase performance we have defined a class named StreamResource. This class encapsulates input data, reads it once and caches it into a temp file; thus data can be traversed many times. StreamResource can read data lazily or in a eager way thus releasing resources early. This class can be used as a variation of PipeStream, which never blocks, as if a size of a buffer is not limited, and which can be read many times.

The API looks like this:

public class StreamResource: IDisposable { /// <summary> /// Creates a StreamSource instance. /// </summary> /// <param name="source"> /// A function that returns source as an input stream. /// </param> /// <param name="settings">Optional settings.</param> public StreamResource(Func<Stream> source, Settings settings = null); /// <summary> /// Creates a StreamSource instance. /// </summary> /// <param name="source"> /// A function that writes source data into an output stream. /// </param> /// <param name="settings">Optional settings.</param> public StreamResource(Action<Stream> source, Settings settings = null); /// <summary> /// Gets an input stream. /// </summary> /// <param name="shared"> /// Indicates that this StreamResouce should be disposed when returned /// stream is closed and there are no more currently opened cache streams. /// </param> /// <returns>A input stream.</returns> public Stream GetStream(bool shared = false); }

The use pattern is following:

// Acquire resource. using(var resource = new StreamResource(() => CallService(params...))) { // Read stream. using(var stream = resource.GetStream()) { ... } ... // Read stream again. using(var stream = resource.GetStream()) { ... } }

StreamResource is efficient even if you need to process content only once, as it monitors timings of reading of source data and compares it with timings of data consumption. If the difference exceeds some threshold then StreamResource caches source greedily, otherwise source is pooled lazily. Thus, input resources can be released promptly. This is important, for example, when the source depends on a database connection.

The use pattern is following:

// Acquire resource and get shared stream. using(var stream = new StreamResource(() => CallService(params...)).GetStream(true)) { ... }

Finally, StreamResource allows to process data in a pipe stream mode. This is when you have a generator function Action<Stream> that can write to a stream, and you want to read that data. The advantage of StreamResource over real pipe stream is that it can work without blocking of generator, thus releasing resources early.

The use pattern is similar to the previous one:

using(var stream = new StreamResource(output => Generate(output, params...)).GetStream(true)) { ... }

The source of the class can be found at Streaming.zip.

Change column type in SQL Server, Part 2

Vladimir Nesterovsky — Fri, 09 Nov 2012 16:41:27 GMT

Two monthes ago we have started a process of changing column type from smallint to int in a big database.

This was splitted in two phases:

Change tables and internal stored procedures and functions.
Change interface API and update all clients.

The first part took almost two monthes to complete. Please read earlier post about the technique we have selected for the implementation. In total we have transferred about 15 billion rows. During this time database was online.

The second part was short but the problem was that we did not control all clients, so could not arbitrary change types of parameters and of result columns.

All our clients use Entity Framework 4 to access the database. All access is done though stored procedures. So suppose there was a procedure:

create procedure Data.GetReports(@type smallint) as begin select Type, ... from Data.Report where Type = @type; end;

where column "Type" was of type smallint. Now we were going to change it to:

create procedure Data.GetReports(@type int) as begin select Type, ... from Data.Report where Type = @type; end;

where "Type" column became of type int.

Our tests have shown that EF bears with change of types of input parameters, but throws exceptions when column type has been changed, even when a value fits the range. The reason is that EF uses method SqlDataReader.GetInt16 to access the column value. This method has a remark: "No conversions are performed; therefore, the data retrieved must already be a 16-bit signed integer."

Fortunately, we have found that EF allows additional columns in the result set. This helped us to formulate the solution. We have updated the procedure definition like this:

create procedure Data.GetReports(@type int) as begin select cast(Type as smallint) Type, -- deprecated Type TypeEx, ... from Data.Report where Type = @type; end;

This way:

result column "Type" is declared as deprecated;
old clients still work;
all clients should be updated to use "TypeEx" column;
after all clients will be updated we shall remove "Type" column from the result set.

So there is a clear migration process.

P.S. we don't understand why SqlDataReader doesn't support value conversion.

Export data to Excel

Arthur Nesterovsky — Mon, 29 Oct 2012 15:34:38 GMT

If you deal with web applications you probably have already dealt with export data to Excel. There are several options to prepare data for Excel:

generate CSV;
generate HTML that excel understands;
generate XML in Spreadsheet 2003 format;
generate data using Open XML SDK or some other 3rd party libraries;
generate data in XLSX format, according to Open XML specification.

You may find a good article with pros and cons of each solution here. We, in our turn, would like to share our experience in this field. Let's start from requirements:

Often we have to export huge data-sets.
We should be able to format, parametrize and to apply different styles to the exported data.
There are cases when exported data may contain more than one table per sheet or even more than one sheet.
Some exported data have to be illustrated with charts.

All these requirements led us to a solution based on XSLT processing of streamed data. The advantage of this solution is that the result is immediately forwarded to a client as fast as XSLT starts to generate output. Such approach is much productive than generating of XLSX using of Open XML SDK or any other third party library, since it avoids keeping a huge data-sets in memory on the server side.

Another advantage - is simple maintenance, as we achieve clear separation of data and presentation layers. On each request to change formatting or apply another style to a cell you just have to modify xslt file(s) that generate variable parts of XLSX.

As result, our clients get XLSX files according with Open XML specifications. The details of implementations of our solution see in our next posts.

Stream xslt transformation through WCF

Vladimir Nesterovsky — Fri, 03 Aug 2012 22:32:49 GMT

Earlier we have shown how to build streaming xml reader from business data and have reminded about ForwardXPathNavigator which helps to create a streaming xslt transformation. Now we want to show how to stream content produced with xslt out of WCF service.

To achieve streaming in WCF one needs:

1. To configure service to use streaming. Description on how to do this can be found in the internet. See web.config of the sample Streaming.zip for the details.

2. Create a service with a method returning Stream:

[ServiceContract(Namespace = "http://www.nesterovsky-bros.com")] [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)] public class Service { [OperationContract] [WebGet(RequestFormat = WebMessageFormat.Json)] public Stream GetPeopleHtml(int count, int seed) { ... } }

2. Return a Stream from xsl transformation.

Unfortunately (we mentioned it already), XslCompiledTransform generates its output into XmlWriter (or into output Stream) rather than exposes result as XmlReader, while WCF gets input stream and passes it to a client.

We could generate xslt output into a file or a memory Stream and then return that content as input Stream, but this will defeat a goal of streaming, as client would have started to get data no earlier that the xslt completed its work. What we need instead is a pipe that form xslt output Stream to an input Stream returned from WCF.

.NET implements pipe streams, so our task is trivial. We have defined a utility method that creates an input Stream from a generator populating an output Stream:

public static Stream GetPipedStream(Action<Stream> generator) { var output = new AnonymousPipeServerStream(); var input = new AnonymousPipeClientStream( output.GetClientHandleAsString()); Task.Factory.StartNew( () => { using(output) { generator(output); output.WaitForPipeDrain(); } }, TaskCreationOptions.LongRunning); return input; }

We wrapped xsl transformation as such a generator:

[OperationContract] [WebGet(RequestFormat = WebMessageFormat.Json)] public Stream GetPeopleHtml(int count, int seed) { var context = WebOperationContext.Current; context.OutgoingResponse.ContentType = "text/html"; context.OutgoingResponse.Headers["Content-Disposition"] = "attachment;filename=reports.html"; var cache = HttpRuntime.Cache; var path = HttpContext.Current.Server.MapPath("~/People.xslt"); var transform = cache[path] as XslCompiledTransform; if (transform == null) { transform = new XslCompiledTransform(); transform.Load(path); cache.Insert(path, transform, new CacheDependency(path)); } return Extensions.GetPipedStream( output => { // We have a streamed business data. var people = Data.CreateRandomData(count, seed, 0, count); // We want to see it as streamed xml data. using(var stream = people.ToXmlStream("people", "http://www.nesterovsky-bros.com")) using(var reader = XmlReader.Create(stream)) { // XPath forward navigator is used as an input source. transform.Transform( new ForwardXPathNavigator(reader), new XsltArgumentList(), output); } }); }

This way we have build a code that streams data directly from business data to a client in a form of report. A set of utility functions and classes helped us to overcome .NET's limitations and to build simple code that one can easily support.

The sources can be found at Streaming.zip.

Streaming xslt transformation with ForwardXPathNavigator

Vladimir Nesterovsky — Thu, 26 Jul 2012 18:49:51 GMT

In the previous post about streaming we have dropped at the point where we have XmlReader in hands, which continously gets data from IEnumerable<Person> source. Now we shall remind about ForwardXPathNavigator - a class we have built back in 2002, which adds streaming transformations to .NET's xslt processor.

While XslCompiledTransform is desperately obsolete, and no upgrade will possibly follow; still it's among the fastest xslt 1.0 processors. With ForwardXPathNavigator we add ability to transform input data of arbitrary size to this processor.

We find it interesting that xslt 3.0 Working Draft defines streaming processing in a way that closely matches rules for ForwardXPathNavigator:

Streaming achieves two important objectives: it allows large documents to be transformed without requiring correspondingly large amounts of memory; and it allows the processor to start producing output before it has finished receiving its input, thus reducing latency.

The rules for streamability, which are defined in detail in 19.3 Streamability Analysis, impose two main constraints:

The only nodes reachable from the node that is currently being processed are its attributes and namespaces, its ancestors and their attributes and namespaces, and its descendants and their attributes and namespaces. The siblings of the node, and the siblings of its ancestors, are not reachable in the tree, and any attempt to use their values is a static error. However, constructs (for example, simple forms of xsl:number, and simple positional patterns) that require knowledge of the number of preceding elements by name are permitted.
When processing a given node in the tree, each descendant node can only be visited once. Essentially this allows two styles of processing: either visit each of the children once, and then process that child with the same restrictions applied; or process all the descendants in a single pass, in which case it is not possible while processing a descendant to make any further downward selection.

The only significant difference between ForwardXPathNavigator and xlst 3.0 streaming is in that we reported violations of rules for streamability at runtime, while xslt 3.0 attempts to perform this analysis at compile time.

Here the C# code for the xslt streamed transformation:

var transform = new XslCompiledTransform(); transform.Load("People.xslt"); // We have a streamed business data. var people = Data.CreateRandomData(10000, 0, 0, 10000); // We want to see it as streamed xml data. using(var stream = people.ToXmlStream("people", "http://www.nesterovsky-bros.com")) using(var reader = XmlReader.Create(stream)) using(var output = File.Create("people.html")) { // XPath forward navigator is used as an input source. transform.Transform( new ForwardXPathNavigator(reader), new XsltArgumentList(), output); }

Notice how XmlReader is wrapped into ForwardXPathNavigator.

To complete the picture we need xslt that follows the streaming rules:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" xmlns:d="http://www.nesterovsky-bros.com" exclude-result-prefixes="msxsl d"> <xsl:output method="html" indent="yes"/>  <xsl:template match="/d:people"> <html> <head> <title>List of persons</title> <style type="text/css"> .even { } .odd { background: #d0d0d0; } </style> </head> <body> <table border="1"> <tr> <th>ID</th> <th>First name</th> <th>Last name</th> <th>City</th> <th>Title</th> <th>Age</th> </tr> <xsl:for-each select="d:person">  <xsl:variable name="person"> <xsl:copy-of select="."/> </xsl:variable> <xsl:variable name="position" select="position()"/> <xsl:apply-templates mode="snapshot" select="msxsl:node-set($person)/d:person"> <xsl:with-param name="position" select="$position"/> </xsl:apply-templates> </xsl:for-each> </table> </body> </html> </xsl:template> <xsl:template mode="snapshot" match="d:person"> <xsl:param name="position"/> <tr> <xsl:attribute name="class"> <xsl:choose> <xsl:when test="$position mod 2 = 1"> <xsl:text>odd</xsl:text> </xsl:when> <xsl:otherwise> <xsl:text>even</xsl:text> </xsl:otherwise> </xsl:choose> </xsl:attribute> <td> <xsl:value-of select="d:Id"/> </td> <td> <xsl:value-of select="d:FirstName"/> </td> <td> <xsl:value-of select="d:LastName"/> </td> <td> <xsl:value-of select="d:City"/> </td> <td> <xsl:value-of select="d:Title"/> </td> <td> <xsl:value-of select="d:Age"/> </td> </tr> </xsl:template> </xsl:stylesheet>

So, we have started with a streamed entity data, proceeded to the streamed XmlReader and reached to the streamed xslt transformation.

But at the final post about streaming we shall remind a simple way of building WCF service returning html stream from our xslt transformation.

The sources can be found at Streaming.zip.

Dictionary extension

Vladimir Nesterovsky — Wed, 25 Jul 2012 05:54:33 GMT

If you're using .NET's IDictionary<K, V> you have probably found its access API too boring. Indeed at each access point you have to write a code like this:

MyValueType value; var hasValue = dictionary.TryGetValue(key, out value); ...

In many, if not in most, cases the value is of a reference type, and you do not usually store null values, so it would be fine if dictionary returned null when value does not exist for the key.

To deal with this small nuisance we have declared a couple of accessor extension methods:

public static class Extensions { public static V Get<K, V>(this IDictionary<K, V> dictionary, K key) where V: class { V value; if (key == null) { value = null; } else { dictionary.TryGetValue(key, out value); } return value; } public static V Get<K, V>(this IDictionary<K, V> dictionary, K? key) where V: class where K: struct { V value; if (key == null) { value = null; } else { dictionary.TryGetValue(key.GetValueOrDefault(), out value); } return value; } }

These methods simplify dictionary access to:

var value = dictionary.Get(key); ...

Streaming entity data

Vladimir Nesterovsky — Sun, 22 Jul 2012 20:38:29 GMT

For some reason neither .NET's XmlSerializer nor DataContractSerializer allow reading data through an XmlReader. These APIs work other way round writing data into an XmlWriter. To get data through XmlReader one needs to write it to some destination like a file or memory stream, and then to read it using XmlReader. This complicates streaming design considerably.

In fact the very same happens with other .NET APIs.

We think the reason of why .NET designers preferred XmlWriter to XmlReader in those APIs is that XmlReader's implementation is a state machine like, while XmlWriter's implementation looks like a regular procedure. It's much harder to manually write and to support a correct state machine logic than a procedure.

If history would have gone slightly different way, and if yield return, lambda, and Enumerator API appeared before XmlReader, and XmlWriter then, we think, both these classes looked differently. Xml source would have been described with a IEnumerable<XmlEvent> instead of XmlReader, and XmlWriter must be looked like a function receiving IEnumerable<XmlEvent>. Implementing XmlReader would have meant a creating a enumerator. Yield return and Enumerable API would have helped to implement it in a procedural way.

But in our present we have to deal with the fact that DataContractSerializer should write the data into XmlWriter, so let's assume we have a project that uses Entity Framework to access the database, and that you have a data class Person, and data access method GetPeople():

[DataContract(Name = "person", Namespace = "http://www.nesterovsky-bros.com")] public class Person { [DataMember] public int Id { get; set; } [DataMember] public string FirstName { get; set; } [DataMember] public string LastName { get; set; } [DataMember] public string City { get; set; } [DataMember] public string Title { get; set; } [DataMember] public DateTime BirthDate { get; set; } [DataMember] public int Age { get; set; } } public static IEnumerable<Person> GetPeople() { ... }

And your goal is to expose result of GetPeople() as XmlReader. We achieve result with three simple steps:

Define JoinedStream - an input Stream implementation that reads data from a enumeration of streams (IEnumerable<Stream>).
Build xml parts in the form of IEnumerable<Stream>.
Combine parts into final xml stream.

The code is rather simple, so here we qoute its essential part:

public static class Extensions { public static Stream JoinStreams(this IEnumerable<Stream> streams, bool closeStreams = true) { return new JoinedStream(streams, closeStreams); } public static Stream ToXmlStream<T>( this IEnumerable<T> items, string rootName = null, string rootNamespace = null) { return items.ToXmlStreamParts<T>(rootName, rootNamespace). JoinStreams(false); } private static IEnumerable<Stream> ToXmlStreamParts<T>( this IEnumerable<T> items, string rootName = null, string rootNamespace = null) { if (rootName == null) { rootName = "ArrayOfItems"; } if (rootNamespace == null) { rootNamespace = ""; } var serializer = new DataContractSerializer(typeof(T)); var stream = new MemoryStream(); var writer = XmlDictionaryWriter.CreateTextWriter(stream); writer.WriteStartDocument(); writer.WriteStartElement(rootName, rootNamespace); writer.WriteXmlnsAttribute("s", XmlSchema.Namespace); writer.WriteXmlnsAttribute("i", XmlSchema.InstanceNamespace); foreach(var item in items) { serializer.WriteObject(writer, item); writer.WriteString(" "); writer.Flush(); stream.Position = 0; yield return stream; stream.Position = 0; stream.SetLength(0); } writer.WriteEndElement(); writer.WriteEndDocument(); writer.Flush(); stream.Position = 0; yield return stream; } private class JoinedStream: Stream { public JoinedStream(IEnumerable<Stream> streams, bool closeStreams = true) ... } }

The use is even more simple:

// We have a streamed business data. var people = GetPeople(); // We want to see it as streamed xml data. using(var stream = people.ToXmlStream("persons", "http://www.nesterovsky-bros.com")) using(var reader = XmlReader.Create(stream)) { ... }

We have packed the sample into the project Streaming.zip.

In the next post we're going to remind about streaming processing in xslt.

Weekend C# puzzle

Vladimir Nesterovsky — Sun, 08 Apr 2012 09:18:29 GMT

Several days ago we've arrived to the blog "Recursive lambda expressions". There, author asks how to write a lambda expression that calculates a factorial (only expression statements are allowed).

The problem by itself is rather artificial, but at times you feel an intellectual pleasure solving such tasks by yourself. So, putting original blog post aside we devised our answers. The shortest one goes like this:

As C# lambda expression cannot refer to itself, so it have to receive itself as a parameter, so:

factorial(factorial, n) = n <= 1 ? 1 : n * factorial(factorial, n - 1);
To define such lambda expression we have to declare a delegate type that receives a delegate of the same type:

delegate int Impl(Impl impl, int n);
Fortunately, C# allows this, but a workaround could be used even if it were not possible.
To simplify the reasoning we've defined a two-expression version:

Impl impl = (f, n) => n <= 1 ? 1 : n * f(f, n - 1); Func<int, int> factorial = i => impl(impl, i);
Finally, we've written out a one-expression version:

Func<int, int> factorial = i => ((Func<Impl, int>)(f => f(f, i)))((f, n) => n <= 1 ? 1 : n * f(f, n - 1));
The use is:

var f = factorial(10);

After that excercise we've returned back to original blog and compared solutions. We can see that author appeals to a set theory but for some reason his answer is more complex than nesessary, but comments contain variants that analogous to our answer.

Languages XOM update

Vladimir Nesterovsky — Fri, 23 Mar 2012 00:07:35 GMT

This time we update csharpxom to adjust it to C# 4.5. Additions are async modifier and await operator.

They are used to simplify asynchronous programming.

The following example from the msdn:

private async Task<byte[]> GetURLContentsAsync(string url) { var content = new MemoryStream(); var request = (HttpWebRequest)WebRequest.Create(url); using(var response = await request.GetResponseAsync()) using(var responseStream = response.GetResponseStream()) { await responseStream.CopyToAsync(content); } return content.ToArray(); }

looks like this in csharpxom:

Shifting to client side web applications

Vladimir Nesterovsky — Thu, 08 Mar 2012 21:56:19 GMT

For a long time we were developing web applications with ASP.NET and JSF. At present we prefer rich clients and a server with page templates and RESTful web services.

This transition brings technical questions. Consider this one.

Browsers allow to store session state entirely on the client, so should we maintain a session on the server?

Since the server is just a set of web services, so we may supply all required arguments on each call.

At first glance we can assume that no session is required on the server. However, looking further we see that we should deal with data validation (security) on the server.

Think about a classic ASP.NET application, where a user can select a value from a dropdown. Either ASP.NET itself or your program (against a list from a session) verifies that the value received is valid for the user. That list of values and might be other parameters constitute a user profile, which we stored in session. The user profile played important role (often indirectly) in the validation of input data.

When the server is just a set of web services then we have to validate all parameters manually. There are two sources that we can rely to: (a) a session, (b) a user principal.

The case (a) is very similar to classic ASP.NET application except that with EnableEventValidation="true" runtime did it for us most of the time.
The case (b) requires reconstruction of the user profile for a user principal and then we proceed with validation of parameters.

We may cache user profile in session, in which case we reduce (b) to (a); on the other hand we may cache user profile in Cache, which is also similar to (a) but which might be lighter than (at least not heavier than) the solution with the session.

What we see is that the client session does not free us from server session (or its alternative).

.NET Dictionary nuisance

Vladimir Nesterovsky — Wed, 29 Feb 2012 20:42:46 GMT

We were dealing with a datasource of (int? id, string value) pairs in LINQ. The data has originated from a database where id is unique field. In the program this datasource had to be seen as a dictionary, so we have written a code like this:

var dictionary = CreateIDValuePairs().ToDictionary(item => item.ID, item => item.Value);

That was too simple-minded. This code compiles but crashes at runtime when there is an id == null.

Well, help warns about this behaviour, but anyway this does not make pain easier.

In our opinion this restriction is not justified and just complicates the use of Dictionaty.

eXperanto project actual yet...

Arthur Nesterovsky — Thu, 10 Nov 2011 22:14:09 GMT

A bit history: the first release of this solution was about 9.5 years ago...

Today we've run into a strange situation. One of our clients ask us about automatic conversion of data from mainframe (that were defined as COBOL copybooks) into XML or Java/.NET objects. On our suggestion to use eXperanto, which is well known to him, he stated that he wouldn't like to use a tool of a company that is no more exists...

The situation, in our opinion, become more strange when you consider the following:

eXperanto (the design-time tool and run-time libraries for Java and .NET) were developed, well tested, and delivered by us to production already several years ago.
the client bought this set (the tool and libraries).
the set is in production yet already in another big company, and is used time to time by our company in different migration projects.
the client talks with developers of this tool and run-time libraries, and he knows about this fact.
the client uses widely open source solutions even without dedicated vendors or support warranties.

Entity Framework and char parameters

Vladimir Nesterovsky — Tue, 06 Sep 2011 21:11:38 GMT

We're not big fans of Entity Framework, as we don't directly expose the database structure to the client program but rather through stored procedures and functions. So, EF for us is a tool to expose those stored procedures as .NET wrappers. This limited use of EF still greatly automates the data access code.

But what we have lately found is that the EF has a problem with char parameters. Namely, if you import a procedure say MyProc that accepts char(1), and then will call it through the generated wrapper, the you will see in sql profiler that char(1) parameter is passed with many trailing spaces as if it were char(8000). There isn't necessity to prove that this is highly ineffective.

We can see that the problem happens in VS 2010 designer rather than in the EF runtime, as SP's parameters are not attributed with length, see model xml (*.edmx):

<Function Name="MyProc" Schema="Data"> ... <Parameter Name="recipientType" Type="char" Mode="In" /> ... </Function>

while if we set:

<Parameter Name="recipientType" Type="char" MaxLength="1" Mode="In" />

the runtime starts working as expected. So the workaround is to fix model file manually.