Skip to main content

Posts

Showing posts with the label T4

T4, Generating interface automatically based on provided classes

With new techniques and patterns interface plays a key role in application architecture. Interface makes application extendable like defining file upload interface and implementing based on file system, Azure Blob storage, Amazon S3. At starting we might be implementing based on Azure Blob but later we might move to Windows based file system and so on. Ideally we create interface based on need and start implementing actual default implementation class. Many a times at starting of implementation there is one to one mapping between Interface and Class. Like from above example File upload interface and the initial or default class implementation that we design and with time it will get extended. In this article, we will try to create interface based on default class implementation. This is not at all recommended in Test Driven Design (TDD) where we test the application before actual code implementation but I feel sometimes and in some situations it is okay do that and test straig...

Architecture solution composting Repository Pattern, Unit Of Work, Dependency Injection, Factory Pattern and others

Project architecture is like garden, we plant the things in certain order and eventually they grow in similar manner. If things are planted well then they will all look(work) great and easier to manage. If they grow as cumbersome it would difficult to maintain and with time more problems would be happening in maintenance. There is no any fixed or known approach to decide project architecture and specially with Agile Methodology. In Agile Methodology, we cannot predict how our end products will look like similarly we cannot say a certain architecture will fit well for entire development lifespan for project. So, the best thing is to modify the architecture as per our application growth. I understand that it sounds good but will be far more problematic with actual development. If it is left as it is then more problems will arise with time. Just think about moving plant vs a full grown tree. Coming to technical side, In this article, I will be explaining about the various techniques ...

Strong typed MVC routing on TypeScript/JavaScript

Very often we mess up with routing by giving path which does not exist due to various reason like spelling mistake, name confusions etc. for forming correct URLs . This happens on both server side codes and client side code. There are few strong typed routing provider library present for server side but none is present on the client side. We will look into creating a classes and function to set up our routing paths which will help us to give correct URL based on MVC routing. The idea is to create T4 template file which will be generating client side codes based on MVC routing. I have tried to keep it simple in this version which reads up MVC controllers and public function. The end result looks like this, which is TypeScript code. Makes it pretty simple to use these classes directly without worrying about correct URLs. module Routing { export declare var DomainName: string; export function GetDomainName(): string { return (DomainName != undefined && ...

Auto fluent mapping generation for OpenAccess/Telerik DataAccess through T4

There is two way to map code first with DB related entities. The first is data annotation which is like setting attributes and the other one is fluent mapping. Fluent mapping is very powerful and flexible approach to map entities. The only downside of fluent mapping is incompatibility with client side validation where as MVC has inbuilt functionality to validate on client side with data annotation. We will look into basic fluent mapping generation along with data annotation if present. Default data annotation is not compatible with Telerik DataAccess/OpenAccess. This article does not gives information about how fluent mapping works or how to generate it but auto generation of fluent mapping by any give model. Pre-requisites for fluent generation I have took help of two different libraries to generate fluent mapping for OpenAccess. -  MultiOutput.ttinclude  ( https://github.com/subsonic/SubSonic-3.0-Templates/blob/master/ActiveRecord/MultiOutput.ttinclude ) : This is to ...

Strongly typed configuration through database

We usually save most of application setting under app.config or web.config with key and value pair under appSetting element. The big problem with those are whenever you need value, typecasting need to be done and also need to be called through key. The other problem I find is with hierarchy of settings like download related setting present should under download element for easy accessing. To solve strongly typed configuration and hierarchy, ConfigurationManager ( http://msdn.microsoft.com/en-us/library/system.configuration.configurationmanager(v=vs.110).aspx ) class comes for rescue. You might have seen under web.config where we have sectionGroup and related configuration under elements. To implement it, lot of codes need to written to achieve simplification. To reduce numbers of codes for implementing XML configuration a very good and free tool is available called "Configuration Section Designer" available on http://csd.codeplex.com/ . There we do not have to wri...