Roslyn compilers and Visual Studio

Microsoft has been pretty secret with its products up until the recent years. I can say that in the past couple of years Microsoft has made big steps in the direction of open source.

One of its best and recent initiatives is the Roslyn open-source compilers which are be promised to come with the new version of Visual Studio 2014. I’d say that this is a huge improvement but you may wonder what this really means for the developers.
Well, aside from the fact that they’re open source and you can actually look into the code of the C# compiler there are a lot of more implications.
First of all, this opens the door to the a new era of C# scripting because as of now Roslyn allows you to actually write, compile and run C# code within an application that’s already running, that’s impressive.
Of course there are innovations in the area of refactoring and code analysis but that’s just the beginning of this powerful change. Roslyn also open the door to other open source initiatives such as Mono but let’s see where it goes.

Roslyn is in CTP now and there are things that are still subject to change but what is to come is really interesting.

I will soon post some code snippets ūüôā

 

Either way I am excited!

More info here: Roslyn
[spoiler title=”C# code snippets of Roslyn scripting”]

_context = context;
_engine = new ScriptEngine();
ScriptEngineLoadAssemblies(_engine, context.GetType().Assembly.Location);
_currentModule = context.GetType().ToString();
Session = _engine.CreateSession(context, context.GetType());
private void LoadAssemblies()
{
try
{
//with _session.Execute("code"); you can execute any C# code you want
_session.Execute(
"using System;using System.ComponentModel;" +
"using System.ComponentModel.Composition;" +
"using System.IO;using System.Linq;" +
"using System.Runtime.Serialization;" +
"using System.ServiceModel;" +
"using System.Windows;");
}
catch (Exception e)
{

}

}

public void ScriptEngineLoadAssemblies(ScriptEngine engine, string localAssembly)
{
//GAC Assemblies
var systemCoreReference = MetadataReference.CreateAssemblyReference("System.Core");
var systemReference = MetadataReference.CreateAssemblyReference("System");
var systemComponentModel = MetadataReference.CreateAssemblyReference("System.ComponentModel");
var systemComponentModelComposition =
MetadataReference.CreateAssemblyReference("System.ComponentModel.Composition");
var systemIO = MetadataReference.CreateAssemblyReference("System.IO");
var systemLinq = MetadataReference.CreateAssemblyReference("System.Linq");
var systemReflection = MetadataReference.CreateAssemblyReference("System.Runtime.Serialization");
var systemServiceModel = MetadataReference.CreateAssemblyReference("System.ServiceModel");
var systemWindows = MetadataReference.CreateAssemblyReference("System.Windows");

//Custom Assemblies

engine.AddReference(systemCoreReference);
engine.AddReference(systemReference);
engine.AddReference(systemComponentModel);
engine.AddReference(systemComponentModelComposition);
engine.AddReference(systemIO);
engine.AddReference(systemLinq);
engine.AddReference(systemReflection);
engine.AddReference(systemServiceModel);
engine.AddReference(systemWindows);
engine.AddReference(localAssembly);

}

Basically you need the scriptengine, a session and a context where the code is executed.
[/spoiler]

WPF and MVVM

I am going to assume you know WPF and C# fairly well and going to speak about MVVM design pattern and how these blend together.
I will first expose the reasons behind all the hassle. The reason is that we want to separate between the UI and the functionality and the logic. UI can be very volatile, changing often and can involve complex designing and we don’t want the functionalities and logic to be UI dependent.

Design patterns can provide us the means to do that,however, in simple applications, the use of design pattern can turn into a real useless headache therefore design patterns are particular useful and should be used for business applications, large applications in general.
The MVVM(Model-View-ViewModel) was developed by Microsoft and makes full advantage of the WPF technologies. The keyword in MVVM is binding, as the view bind to properties of a ViewModel which in turn exposes data contained in model objects to the view. If a property value changes in the ViewModel, those new values automatically propagate to the view due to the data binding.
When a button is clicked in the View, a command on the ViewModel performs the requested action. The ViewModel performs data operations, never the View.
This is often called loosely coupled design because the View is not aware of the ViewModel and the ViewModel doesn’t care how the data is displayed and as well as the fact that you don’t have to write extra code to update the view when the data changes.
Another huge advantage of this approach is that writing unit tests are fairly easy, as they are written on the ViewModel and you don’t interact with the UI and makes the testing of functionality easy and natural.

So the ViewModel is basically a class which implements properties and command to which the view can bind and notifies the view of any state change through change notification events.
The properties and commands from the ViewModel define the functionalities to be offered by the UI, but the View determines how the functionality is going to be rendered.
The ViewModel can manipulate the model data so that it can be easily consumed by the View. It can also define additional properties to support the view, but those would normally not belong to the model. For example it can define a property that combines the first name and last name into one property to make it easier for the view to display it.
Another functionality of the ViewModel is validation logic to ensure data consistency.
To summarize, the view model has the following key characteristics:

  • The view model is a non-visual class and does not derive from any WPF base class. It encapsulates the presentation logic required to support a use case or user task in the application. The view model is testable independently of the view and the model.
  • The view model typically does not directly reference the view. It implements properties and commands to which the view can data bind. It notifies the view of any state changes via change notification events via the INotifyPropertyChanged and INotifyCollectionChanged interfaces.
  • The view model coordinates the view’s interaction with the model. It may convert or manipulate data so that it can be easily consumed by the view and may implement additional properties that may not be present on the model. It may also implement data validation via the IDataErrorInfo or INotifyDataErrorInfo interfaces.
  • The view model may define logical states that the view can represent visually to the user.

The Model is also a class that encapsulates business logic and data. By business logic I mean any rules, restrictions and management of the data that a particular business has.
The Model offers support for property and collection changed notification though the INotifyPropertyChanged and INotifyCollectionChanged interfaces. Model classes that are collections usually derive from the ObservableCollection class which already implements the INotifyCollectionChanged interface.

To wire up everything together WPF uses data bindings and provides really powerful capabilities. Data bindings are either one-way or two-way: one-way refers that the UI simply reflects the value of underlying data but the two-way automatically updates the UI when the data is changed(using the above mentionated interfaces).
WPF data binding supports binding to nested properties via the Path property.

This is just an introduction to the MVVM pattern use within WPF and does not cover a very important chapter: data bindings. Maybe I’ll cover it on another post.

Windows 8 Apps Development

This is somehow related to the previous C# articles but also speaks about Windows 8 (8.1.) environment.

As you probably know already Windows 8 has it’s own store and and as it is quite new it can be a good way to make your entry in mobile devices world.
I will briefly present what languages are at your disposal when developing Windows 8 apps and get more into C# and .NET.

Windows 8 start screen supports a tiled layout, where each tile represents an application installed on the machine. Unlike a typical Windows desktop application, Windows 8 applications are built for touch-screen interactions. They are also run in full-screen renderings and lack the usual “chrome” (e.g., menu systems, status bars, and toolbar buttons) we see in many desktop applications.
Building a Windows 8 application requires developers to adhere to an entirely new set of UI design guidelines, data storage methodologies, and user input options. To be sure, a Win8 app is much more than a tile installed on the Windows 8 start screen.

Creating and running a Windows 8 application is only possible on Windows 8 and is not supported under Windows 7. In fact, if you install Visual Studio on Windows 7 (or earlier), you will not even see Windows 8 project templates appear in the New Project dialog box.

So as I previously mentioned we can develop applications in .NET (mostly any .NET aware language) and XAML which is not quite new as we do have XAML in Silverlight and WPF.
There’s HTML5 and CSS3, there is Javascript and that awesome bouncing back language, what was it? Oh, C++.

Coding a Little C++
Why C++ ?
It is much closer to the operating system than .NET and gives very fine-grained control over the UI and device interactions.
It is possible ‚ÄĒ even recommended ‚ÄĒ to build Windows 8 application logic in C++. Games, especially, benefit from the large amount of existing code in the community and strong library support. C++ applications are likely faster than HTML5 or .NET, providing an outlet for very processor-heavy tasks. And, as with .NET, C++ libraries can be consumed by HTML5 Windows 8 applications, too.

So back to the .NET and C#

Programming a Windows 8 application requires developers toR tap into an entirely new runtime layer termed (appropriately enough) Windows Runtime (WinRT). Be very aware that WinRT is not the .NET CLR, however it does offer some similar services such as garbage collection.

In addition, these applications are created using a completely new set of namespaces, all of which begin with the root name Windows.
The Windows.* namespaces offer functionality that mirrors many APIs of the .NET base class libraries. In fact, from a programming point of view, building an application for WinRT feels very similar to building a .NET application for the CLR.
As well, many of the Windows.* namespaces offer similar (though not identical) functionality as is found in the .NET base class libraries.

In addition to the Windows.* namespaces, Windows 8 applications can also make use of a large subset of the .NET platform. Collectively, the .NET APIs for Windows 8 applications, provide support for generic collections, LINQ, XML document processing, I/O services, security services etc.
Just keep in mind that .NET proper is not used to build Windows 8 applications. Rather, you will make use of new libraries (Windows.*), a new runtime (WinRT), and a subset of .NET proper (the .NET APIs) to create such a program.

The keyword here is “subset” as from my own personal experience I learned that you have limited access to what you were used to from WPF and WF applications. One simple example I can think of is that in WinRT you are not able to access an SQL Server which I find rather disturbing as not everyone has an Azure subscription and the SQLite is no match for SQL Server.

Sadly I am unable to provide you free books on this matter as there are not any good free books. However you can find plenty of resources on ACM learning platform if you have a subscription.
For that reason I will try to write more articles on this field, including Hands-ON articles to get you started as well as recommendation of other resources on this area.

Further intro to C#

I’ve got some positive feedback on the article with C# so I decided to do a bit more digging into the subject.

So, you’re interested in coding in C# but you are not really sure what is best for you. Supposedly you are not interested in Console Applications and you want something with a nice interface you have to choices: Windows Forms and WPF. In the following lines I’ll speak about the two.

Windows Forms it’s definitely easy: easy to learn, easy to use and ¬†has huge documentation, support and APIs, being here for quite a while now. There are also a lot more devs on Windows Forms than on WPF. It’s easy to learn and use because of “Drag and Drop” feature by which you can build a functional application very fast. If you are in need of an app that does something and you are not really interested on how does it look you can go for Windows Forms.
Usually, you’re using Windows Forms to do something (internal) and you don’t have much time at disposal.

Windows Presentation Foundation(WPF) on the other hand is newer, fewer devs working with it and it’s a bit harder to learn to new comers. In WPF you have much more freedom of design and if you would wanted a professional app (i.e. for clients) you should go for WPF. The look and feel is just great, it looks modern and behave accordingly. In WPF you can add lots of animations, transitions, making it suitable for end-users UI. However there is a bit of a trouble to new comers, why is that exactly?
Well, because there is an XML (XAML) component which is in charge of design and not many people are used to it first hand, but once you get used it, it’s really great: it is more maintainable, cleaner and you can control your elements very precisely.
There is also the advantage of data binding, as WPF is great with it having behind it the MVVM pattern (Model – View View – Model) .
Also, if you’re learning WPF now it’s going to be much easier for you to design and code Windows 8 (8.1) Apps or Windows Phone apps as those apps have similar behavior.

EDIT: What I forgot to mention is that Windows Forms is portable to other platforms through the Mono Project but WPF is not.

Code snippets:

[gist id=8639173 file=WindowsForms]

[gist id=8639173 file=WPF]

 

To summarize, you use Windows Forms when you want something fast and you don’t care that much about the interface and WPF when you want something more elaborate and UI is a decisive factor. Keep in mind that Windows Forms it’s easier to learn and use and WPF represents somehow the future.

 

Intro to C#

Hello everyone!

Today I am going to talk you about C#, what’s nice about it, why one would learn it and why should you?

C# is one of the high level languages due to its high abstractization level. This means that each instruction is translated into much machine code but it offers to programmer the possibility to express complicated things with few code lines.
C# it’s also a pure OO (Objected Oriented) Language, except for the primitive types (int, double, string…) meaning that everything is an object (there are also wrapper classes for the primitive types: Double, String …)

It has a big advantage having the syntax similar to C or C++ if you’re familiar with OOP concepts. Being an evolved language it has a garbage collector meaning you don’t have to worry about memory management.
Despite many people are saying C# it’s not portable this is not actually true. Thanks to MonoDevelop, an open source IDE (I am also contributing to it – you can too!) you can now code in C# on Linux and you can code applications for Android up to .NET 4.5 and C# 4.0.

So why is it so great?
Well, because you can do complicated stuff very easy and straightforward and it’s easy to learn if you are already familiar with C/C++.
C# has been designed to be simple and it works great. It has a the best IDE namely Visual Studio 20xx(2013 is the last version, but 2008,2010,2012 versions also exist). Some of people would say this it’s very expensive(there is also an Express version which is FREE) but for students it’s free anyway(through Microsoft’s partnership with various universities).
There is also another advantage that C# has now. You can develop applications for Windows 8 and Windows Phone 8, two fast growing OS for PC and mobile respectively.

Through the .NET initiative you can design Windows Forms, WPF (Windows Presentation Foundation), WCF (Windows Communication Foundation) applications with C#.
So, if you want to get started programming some real world applications, C# can be an excellent choice, being a modern and ever developing language.

But as I always recommend when learning something new: Work on a fun project! Learning should be fun ūüôā

Some code snippet:

using System;  //System is a namespace

class Program
{
    static void Main() //Entry Point in our program
    {
        Console.WriteLine("Hello world!"); //Note that Console it's a class and WriteLine it's a method(function)
    }
}

If you have further questions do not hesitate to contact me.
Now I have 2 books to start with, both free. Personally I think the first it’s better. Enjoy!

Fundamentals-of-Computer-Programming-with-CSharp-Nakov-eBook-v2013 csharp_ebook

csharp_ebook

Simple Share Buttons