The open .NET Ecosystem : Introducing OmniSharp – Making cross platform Dot Net a Reality

The open .NET Ecosystem : Introducing OmniSharp – Making cross platform Dot Net a Reality

Dot Net suffered a great set setback during last decade for having its code confidential. But now it’s happening  and I think it’s both the end of an era but also the beginning of amazing things to come.

  • Open source and cross platform.
    • .NET Core 5 is the modern, componentized framework that ships via NuGet. That means you can ship a private version of the .NET Core Framework with your app. Other apps’ versions can’t change your app’s behavior.
    •  .NET Core CLR for Windows, Mac and Linux and it will be both open source and it will be supported by Microsoft. It’ll all happen at https://github.com/dotnet.
    • Open sourcing the RyuJit and the .NET GC and making them both cross-platform.
  • ASP.NET 5 will work everywhere.
    • ASP.NET 5 will be available for Windows, Mac, and Linux. Mac and Linux support will come soon and it’s all going to happen in the open on GitHub at https://github.com/aspnet.
    • ASP.NET 5 will include a web server for Mac and Linux called kestrel built on libuv. It’s similar to the one that comes with node, and you could front it with Nginx for production, for example.
  • Developers should have a great experience.
    • There is a new FREE SKU for Visual Studio for open source developers and students called Visual Studio Community. It supports extensions and lots more all in one download. This is not Express. This is basically Pro.
    • Visual Studio 2015 and ASP.NET 5 will support gulp, grunt, bower and npm for front end developers.
  • Even more open source.
    • Much of the .NET Core Framework 4.6 and its Reference Source source is going on GitHub. It’s beingrelicensed under the MIT license, so Mono (and you!) can use that source code in their .NET implementations.
    • There’s a new hub for Microsoft open source that is hosted GitHub at http://microsoft.github.io.dot net

What’s New In C# 5.0

When we talk about what new features c# 5.0 has then, suddenly the two key features strike in mind. Microsoft Visual Studio 2012 with C# 5.0 provides following key features,

  1. Async Programming
  2. Caller Information

Async Programming: In c# 5.0 with .NET Framework 4.5, we can easily achieve asynchronous programming by using two new key-words,

  1. async
  2. await

async: It is a modifier which is used to create an asynchronous method.

await: It is an operator.

In traditional synchronization programming the user could not interact with UI until the process gets completed.

For example, if an application is trying to access a web resource then the whole application must wait until the request gets completed, which results into a slower interaction with UI.

 

Writing an async method is very simple,

async Task<int> doWorkAsync()

{

int someValue;

………………………..

return someValue;

}

Task<int> returnVal= doWorkAsync();

int result=await returnVal;

or in one line,

int result = await doWorkAsync();

 

Explanation:

  1. async: async is a modifier which tells compiler that it is an async method.
  2. Task<datatype>: Task<datatype> specifies the return type of async method,
    1. Task<int>: Specifies that method will return an Integer.
    2. Task: Specifies that method will not return anything.
    3. void: It is used when you write a handler for async event.
    4. await: It specifies the suspending point for async method, which means that method will not respond further until the awaited process gets completed. It suspends the execution of async method and transfers the control back to the method’s caller then rest of program executes.

 

Caller Information: Caller information is very useful while performing tasks like tracing, debugging, logging etc.

For this purpose Caller Information uses three attributes,

  1. CallerFilePathAttribute: It gets the full path (at compile time) of file which has caller. It is of String type.
  2. CallerLineNumberAttribute: It gets the source file’s line number from where function is being called. It is of Integer type.
  3. CallerMemberNameAttribute: It gets the method/property name of caller. It is of String type.

 

Example:

public void A()

{doWorkAndLog();}

public void B()

{doWorkAndLog();}

public void doWorkAndLog(

[CallerMemberName] string memberName = “”,
[CallerFilePath] string sourceFilePath = “”,
[CallerLineNumber] int sourceLineNumber = 0)

{

Console.WriteLine(“Method Name: {0}”,memberName);

Console.WriteLine(“File Path: {0}”,sourceFilePath);

Console.WriteLine(“Line Number: {0}”,sourceLineNumber);

……………………………………………

}

Note: Caller information attributes must be used as optional parameters, else Caller information will not work.

Now each time when doWorkAndLog method would be called, it would automatically log the information of caller.

Grunt and Gulp Intellisense in Visual Studio 2013

Grunt and Gulp Intellisense in Visual Studio 2013

Update Jan 16, 2015 – The newly released Visual Studio 2015 CTP 5 also supports Grunt/Gulp Intellisense using the files available in this blog post. In fact, the Intellisense will be a lot better in CTP 5 due to the support for Object Literal Intellisense in the JavaScript Editor.

I’ve spent some time figuring out how to get Intellisense working for Grunt and Gulp in the JavaScript editor. Today, I hit a breakthrough that lights up Intellisense automatically. All it requires is that you perform the following two steps:

  1. Download the JavaScript Intellisense files (zip with two .js files)
  2. Copy them to C:\Program Files (x86)\Microsoft Visual Studio 12.0\JavaScript\References

If you’ve installed Visual Studio under a different path, then you’ll have to find the correct folder at that location instead.

This trick also works in Visual Studio 2015 Preview, but then the folder to copy the JavaScript files to is: C:\Program Files (x86)\Microsoft Visual Studio 14.0\JavaScript\References

Here’s what it looks like when editing GulpFile.js:

gulp

And here is GruntFile.js:

Grunt

 

Please give it a try and let me know what you think. Your feedback is super important.

Things to remember while committing .NET code to SVN repository

Things to remember while committing .NET code to SVN repository

While working on .NET projects, I analyzed that most of the developers make some common mistakes while committing code to SVN. So, I have identified those common mistakes and collaborated them as SVN guidelines to be followed for .NET code. Those are as follows:

  1. We should not check in the debug files like .pdb files etc.
  2. We should not check in local settings file.
  3. We should not check in local DLLS.
  4. We should not check in bin and other local folders.
  5. We should not check in debug and published folders or any other information like “My Project” folder.
  6. We should not check in our solution files (.sln) until and unless we have added or removed any vb project.
  7. Never commit .suo file.
  8. We should not check in .vbproj file until and unless we have added or removed any file, sub-folder or reference to that particular project.
  9. We should not check in .vbproj.user file as it is local system specific file of user.
  10. Always remember to commit .vbproj file if you have added or removed any file, sub-folder or reference to that particular project. But before committing the code take a diff of this file and include only file information and not any unnecessary information like compile time changes or local reference changes etc.
  11. We should not check in web.config until and unless there are some code changes that are not user machine specific.
  12. Similarly if you are adding or deleting a project, then always remember to check in .sln file but before that take a diff and check in only the required changes of file and not the local version information.
  13. Always take a difference of all the changes in your folder before you check in. If you are using Tortoise SVN client, then you can follow the below steps:
  • Go to the parent folder of your repository.
  • Right click -> Tortoise SVN -> check for modifications

15

  • This will open up a window listing all the files, folders that are modified
  • Please keep in mind, to check the “Unversioned” which will also display the newly added files in your repository.

16

  •  To include newly added file, you have to right click that particular folder or file and Add into the SVN before commit. If you created new files and/or directories during your development process then you need to add them to source control too. Select the file(s) and/or directory and use TortoiseSVN → Add. If you add a file or folder by mistake, you can undo the addition before you commit using TortoiseSVN → Undo add….
  • If you want to delete some file or folder, you need to right click and Delete into the SVN before commit. When you TortoiseSVN → Delete a file or folder, it is removed from your working copy immediately as well as being marked for deletion in the repository on next commit. The item’s parent folder shows a “modified” icon overlay. Up until you commit the change, you can get the file back using TortoiseSVN → Revert on the parent folder

17

  • you want to delete an item from the repository, but keep it locally as an unversioned file/folder, use Extended Context Menu → Delete (keep local).
  1. If a Subversion command cannot complete successfully, perhaps due to server problems, your working copy can be left in an inconsistent state. In that case you need to use TortoiseSVN → Cleanup on the folder. It is a good idea to do this at the top level of the working copy.
  2. In projects you will have files and folders that should not be subject to version control. These might include files created by the compiler, *.obj, *.lst, *.pdb maybe an output folder used to store the executable. Whenever you commit changes, TortoiseSVN shows your unversioned files, which fills up the file list in the commit dialog. The best way to avoid these problems is to add the derived files to the project’s ignore list. That way they will never show up in the commit dialog, but genuine unversioned source files will still be flagged up. If you right click on a single unversioned file, and select the command TortoiseSVN → Add to Ignore List from the context menu.

18

 

.NET code review made easier with tools

.NET code review made easier with tools

Following are the code review tools:

  1. Code Analysis
  2. Concurrency Analyzer (multithreaded app performance)
  3. Performance Analysis
  4. Code Metrics
  5. Code Redundancy
  6. FxCop (Review Tool)
  7. Logical checks [Pending]
  8. Code Digger (analyzes possible execution paths through your .NET code.)
  9. SSW Code Auditor (ensures code quality)

Code Analysis

In Visual Studio 2012, Microsoft provided features to analyze the code. This can be done in following steps:

1. Open the solution in which the projects that you want to analyze are present.

2. You can analyze full solution or any of the project in that solution.

3. Go to Analyze -> Configure code analysis for solution. It will open a window where you can change Code Analysis Settings.

1

4. You can choose from the Rule Set as Basic Correctness rules, design rules or Microsoft all rules etc as required.

2

 

5. You can change: Configuration and platform also as required. Once configuration is completed then you can analyze the code.

6. Go to Analyze -> Click Run Code Analysis for Solution or Press Alt+F11

7. Once the analysis is completed, a “Code Analysis” window will appear beside solution explorer listing all the errors. When you click on that            error, it will show you the location of that error.

8. From this window you can analyze again full solution or a particular project in that solution by choosing from the above dropdown.

9. Also it provides a settings icon from where you can change the settings again.

3

 

 

 

Concurrency Analyzer (multithreaded app performance)

 

Visual Studio provides in-built “Concurrency Visualizer” to examine the multithreaded app performance.

4

Steps:

  1. Go to Analyze -> Concurrency Visualizer -> Start with Current Project (Shift+Alt+F5)
  2. It may ask you to use install symbols. Once you click Yes, then it will automatically generate a report.

 

 

Performance Analysis

 

Visual Studio provides in-built feature to analyze the performance of the code. Steps to do performance analysis are as follows:

1. Configure Performance Analysis by Selecting the profiling method as follows:

    1. Go to Analyze -> Launch performance Wizard
    2. Select the method of Profiling as “CPU Sampling”
    3. Next -> Select project and finish

5

2. Go to Analyze -> Start Analysis (Alt+F2)

3. It will first do the profiling and then start the performance analysis and gives the reports and a Error List.

6

4. The Report can be exported.

7

 

 

 

Code Metrics (Measuring Complexity)

 

The increased complexity of modern software applications also increases the difficulty of making the code reliable and maintainable. In recent years, many software measures, known as code metrics, have been developed that can help developers understand where their code needs rework or increased testing.

Developers can use Visual Studio Application Lifecycle Management to generate code metrics data that measure the complexity and maintainability of their managed code. Code metrics data can be generated for an entire solution or a single project.

 

Steps to do:

  1. Go to Analyze -> Calculate Code Metrics for Solution
  2. It analyzes and gives the output

8

 

Code Redundancy

 

This feature is available in only “Ultimate and Premium” editions of Visual Studio 2012

 

Steps to do:

  1. Go to Analyze -> Analyze Solution for Code Clones.
  2. Methods that are less than 10 statements long are not scanned by this command.
  3. You can clone a set of statements by selecting that code -> Right Click there -> Choose Find matching clones in solution.

 

 

FxCop (Framework Police)

 

It is a code analysis tool that checks managed code assemblies for Microsoft’s .NET Framework design guidelines and custom guidelines. Using this tool, we can make sure about the coding standards like naming conventions, classes designing, performance etc.

Initial step is to install FxCop setup in your machine. It is a free tool which can be easily available on internet or you can use this link http://www.microsoft.com/en-in/download/details.aspx?id=6544

After installing FxCop, you can use it in two different ways:

  1. Launching FxCop Application directly from All Programs list.
  2. Launching FxCop as an External Tool in Visual Studio.

 

1.    Launching FxCop Application directly from All Programs list.

 

Go to Start Menu -> All Programs -> “Microsoft FxCop” option and then click on Microsoft FxCop. It will launch an empty window as shown below having three panes (sub-windows).

9

 

Now Go to the Project Menu and click on “Add Targets…” Select the project EXE or DLL whose managed code you want to check. Then begin analysis by clicking Analyze button, the screen will look like as below:

10

 

 

The Message Pane will shows the list of all the active messages. These messages are the errors and warning that FxCop has found with the last analysis performed. You can select any one of the message in Message Pane, it will show the message details like error level, certainty and the resolution to resolve it.

 

You can also save the analysis report from File Menu -> Save Report As. The report will be stored as an XML document which will store all the message on assembly level, type level and member level.

2.    Launching FxCop as an External Tool in Visual Studio.

 

Open the project in Visual Studio, then go to Tools -> External Tools -> click Add. Enter the following details in the respective textbox for the newly created External Tool.

 

  • Title: FxCop
  • Command: C:\Program Files (x86)\Microsoft Fxcop 10.0\FxCopCmd.exe
  • Arguments: /c /searchgac /f:$(TargetPath) /d:$(BinDir)
  • Initial directory: C:\Program Files (x86)\Microsoft FxCop 10.0

 

Note: Make sure to mention the correct directory path where FxCop program is being installed and “Use Output Window” checkbox is checked.

After adding the above details, the dialog box will appear as below:

11

 

You can also add your custom rules DLLs which you want to apply on the project and place them in the same path where FxCop rules are present like c:\Program Files (x86)\Microsoft FxCop 1.36\Rules

 

Now you need to run the tool. Go to Tools -> FxCop. The Visual Studio Output window will show the FxCop analysis result.

 

So this tool can help developers in following the best coding practice by analyzing the code.

 

Code Digger

 

Link : http://research.microsoft.com/en-us/projects/codedigger/gettingstarted.aspx

Code Digger analyzes possible execution paths through your .NET code. The result is a table where each row shows a unique behavior of your code. The table helps you understand the behavior of the code, and it may also uncover hidden bugs.

Through the new context menu item “Generate Inputs / Outputs Table” in the Visual Studio editor, you can invoke Code Digger to analyze your code. Code Digger computes and displays input-output pairs. Code Digger systematically hunts for bugs, exceptions, and assertion failures.

 

Out of the box, Code Digger only works on public .NET code that resides in Portable Class Libraries. But if you want to use it over any .NET code, then follow the following steps:

 

  1. Go to Tools -> Extensions & Updates -> Online section -> Search “Code Digger” and download and install it.
  2. Restart Visual Studio
  3. Go To Tools -> Options -> Pex -> General -> Under Code Digger

12

4. Go to any function right click and analyze as follows:

13

14

 

 

SSW Code Auditor

SSW Code Auditor is a code analysis tool that allows developers to take control of your code, ensuring large, complex source code can be simplified, cleaned and maintained.

SSW Code Auditor utilizes the power of Regular Expressions to audit your code. This powerful feature permits the user to write their own set of rules and have different rules for different projects.

Link: http://visualstudiogallery.msdn.microsoft.com/2859b7a1-9b11-4cbe-abde-f1718aa395ab?SRC=VSIDE

http://www.ssw.com.au/ssw/CodeAuditor/

 

Steps:

  1. Go to Tools -> Extensions & Updates -> Online section -> Search “SSW Code Auditor” and download and install it.
  2. Restart Visual Studio
  3. SSW Code Auditor will be now available on the Visual Studio menu
  4. Rest steps can be read from http://www.ssw.com.au/ssw/CodeAuditor/Tutorial.aspx#Started

 

 

Singleton concept

Singleton is an object oriented concept but not well known to most of the developers. Many a times while coding, you come across a requirement wherein you want to restrict the instance of a class to the maximum of one i.e. only one instance of class should exist at a time. Normally we try to resolve this problem through various workarounds. But the perfect solution to this problem is using the “Singleton Class”.

Singleton Class is a class that allows only one instance of itself to be created. It provides global access point throughout the application. It will not allow the object to be created if the one already exists throughout its lifetime.

Singleton class is never instantiated with new method but directly with the class name. It should contain private constructor (to ensure that it is not instantiate in any other way) and a public method that returns the instance.

Any class will be known as Singleton if it satisfies single instance and global access principles.

 

public class Singleton

{

//declaring the unique instance that will exist

private static Singleton uniqueInstance = new Singleton();

//private constructor of the class

private Singleton(){}

//public method that returns instance

public static Singleton getInstance()

{

return uniqueInstance;

}

}

 

Lazy Singleton

In this lazy allocation is done. First the instance is checked if it exists then its reference is returned else the new instance is created.

 

public class Singleton

{

//declaring the unique instance that will exist

private static final Singleton uniqueInstance;

//private constructor of the class

private Singleton(){}

//public method that restricts the duplicate instantiation

public static Singleton getInstance()

{

// if the instance is not yet created, then it creates and returns the new instance

if (uniqueInstance == null)

{

uniqueInstance = new Singleton();

}

//else it just returns the already existing instance

return uniqueInstance;

}

}

Thus from the above code it’s obvious that this class’ object can be created only from one point that is its getInstance() static method and it will be allowed only if no other instance already exists and if it exists, then no other instance will be created but the already existing one is returned. All this is done through:

Singleton singletonObj = Singleton.getInstance();

 

This concept is used in LoadBalancing.

Load Balancing machines implement Singleton concept so that the clients can access its unique instance. Though servers go off or on-line dynamically but there requests should go through the unique object that has knowledge about the state of the web.

Other Examples are:

  • Logger Classes – Instantiate once and then throughout used for logging details.
  • Factories
  • Configuration Classes
  • Shared access to resources

When to use Singleton Class:

  • Singleton is used for state objects i.e. If you are developing an application where the central object’s state matters, Singleton should be used.
  • If your object is heavy and consumes large amount of memory, then its multiple instances should be restricted via Singleton.
  • If you want to prevent multiple instances of an object.

Just in Singleton, you need to design so that it is thread safe if you application is multi-threaded.

Mostly, Singleton is confused with Static Class. But they are different in following aspects:

  • Singleton can implement interfaces while Static can’t.
  • Singleton can be loaded lazily whereas static is initialized whenever it is loaded.
  • Singleton uses Polymorphism concept of Object Oriented whereas static can’t.
  • Singleton objects are stored in heap whereas static objects are stored in stack.

 

A very basic and everyday example of Singleton is:

If you open Notepad++ and write something on it. Now again try to open Notepad++ (i.e. try to instantiate another instance of it), then also it returns the same instance in which you have typed in.

 

3 Tier Architecture in .Net Framework

3 Tier Architecture in .Net Framework

3 tier architecture is very well known approach in the world of software development. A layer is portion of the code, which is supposed to perform a particular action. Three Tier Architecture is an organization of three different layers i.e., Presentation Layer, Business Access Layer and Data Access Layer. Applications following three tier architecture are easy to maintain as each layer is separated from each other, change in one does not affect the other layers

 

Here is the description of all three layers:

Presentation Layer (PL): This is the topmost layer of the application, which a user can access directly. This layer actually consists of UI part of an application and displays the contents. It can either contain webpages or windows forms, which are actually responsible to get the inputs from the user and to display the results. To perform any action in application, Presentation layer has to communicate with BAL (Business Access Layer)

 

Business Access Layer (BAL): This layer contains all the business rules like component validation, communication with database etc. This is the only layer which directly communicates with Presentation and Data Access Layer, so it acts as a bridge between Presentation and Data Access Layers. This layer ensures that the input data is in a standard format before proceeding to Data Layer.

Data Access Layer (DAL): The most important component for any of the application is its data. This layer is responsible to perform database operation like connect with the database, save, retrieve, delete and update the data. DAL sends the results to BAL, which is further responsible to send the same to PL to display the results to the user.

 

Advantage of 3 Tier Architecture:

  • Maintainability: Application becomes easy to maintain, as each layer is an independent, so changes in one layer does not affect the another layer.
  • Flexibility: Once layers are independent, flexibility gets increased
  • Re-usability: Logic placed in Business Access Layer, increases the re-usability