.NET From India

ASP.NET 5 and .NET vNext Overview

With so many changes and fast feature addition happening in .NET, it is very difficult for people to keep up with the changes. I came across this slide deck that gives you a nice overview of the new changes that will give you a high level view into what is changing relating to ASP.NET 5 and also how the .NET framework is also changing.

A nice way to get a high level view in the the changes in 10 minutes...:)

 

Mobile Enabling your Site - Why is this now important

If you have been following this blog, you may have noticed that the design has changed last week. The blog is now responsive and supports rendering to a mobile browser.

One of the reasons this important is that Google is updating their page ranking algorithms. This is something that happens often where minor changes are made. There are also times when a major change happens that has a major impact on the ranking of your site. Except for SEOs most people do not follow this closely.

The difference this time is that Google also change has a major support for mobility. So if your page does not support rendering in mobile browser, then it will get a lower score as per the new algorithm when the search is from a mobile device. So it is important that you make sure that your pages are optimized for mobile. 

As per this post 

Starting April 21, we will be expanding our use of mobile-friendliness as a ranking signal. This change will affect mobile searches in all languages worldwide and will have a significant impact in our search results. Consequently, users will find it easier to get relevant, high quality search results that are optimized for their devices

You can use the Mobile Friendly Test Page to test your web page to confirm that it is detected as mobile friendly.

 

History of Browser Useragent

I came across this nice post. It is old, but still is an interesting read..

http://webaim.org/blog/user-agent-string-history/

Beacons with Xamarin

I few weeks back I started playing around with beacons and use of beacons in enterprise scenarios. Currently only Android and iOS devices support the advertisement mode of beacons and wanted to try out how Xamarin can be used to create cross-platform apps that can use beacons.

One of the libraries that provide a common API to work with beacons is the AltBeacon, which is an open source Beacon library. There is also a Xamarin compatible wrapper for this library at https://components.xamarin.com/view/android-altbeacon-library. Currently this is compatible only with Android (I have not yet come across an iOS and Android compatible free library), but since I was building my test app on Android, I decided to go along.

This post helped me with initial information, but the AltBeacon library has changed and so some steps have changed.

Once you install the AltBeacon library, I would recommend you first try out the sample application. I recommend that so that you can make sure you have the right dependencies and your devices are setup right etc. This helps ensure that if your code is unable to connect using he library, the problem is with the code and not the hardware…

The idea behind the post is to talk about the steps to start working with beacons using the Altbeacon. Rather than dumping code, I wanted to show the steps involved so that you can make sense of the flow and build your apps.

Setting up your project

If you start with a new project, then pls make sure you have the capabilities that are required set correctly. You need BLUETOOTH permission to be set. (In some scenarios you may need BLUETOOTH_ADMIN also set)

Then you need to setup the service entries you need in the AndroidManifest.xml. I just copied the entries from the sample project and this should work ok for you. The entries will be similar to the following:

<application android:label="BeaconDetect" android:icon="@drawable/Icon">
        <service android:enabled="true" android:exported="true" android:isolatedProcess="false" android:label="Beacon" android:name="org.altbeacon.beacon.service.BeaconService"></service>
        <service android:enabled="true" android:name="org.altbeacon.beacon.BeaconIntentProcessor">
            <meta-data android:name="background" android:value="true" />
            <intent-filter android:priority="1">
                <action android:name="org.altbeacon.xamarinbeaconreference.MSG_STOP_RANGING" />
                <action android:name="org.altbeacon.xamarinbeaconreference.MSG_STOP_MONITORING" />
                <action android:name="org.altbeacon.xamarinbeaconreference.MSG_START_RANGING" />
                <action android:name="org.altbeacon.xamarinbeaconreference.MSG_START_MONITORING" />
            </intent-filter>
        </service>
        <receiver android:name="org.altbeacon.beacon.startup.StartupBroadcastReceiver">
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
                <action android:name="android.intent.action.ACTION_POWER_CONNECTED" />
                <action android:name="android.intent.action.ACTION_POWER_DISCONNECTED" />
            </intent-filter>
        </receiver>
    </application>

Now your project is setup.

Detecting the Beacon

I would recommend you use the sample code and build on that. But it takes quite a bit of effort to understand the flow. The application flow is as follows.

1. You main activity implement the interface IBeaconConsumer
2. Check if Bluetooth is available using the CheckAvailability() static method of the BeaconManager
3. Get an instance of BeaconManager using the GetInstanceForApplication Method and passing your main activity as a parameter as it is what is going to receive the Detect message (in the case of the sample)
4. Add an Beacon Parser. There is code in the sample that is marked as working for Estimote. I found this worked fine for Gimbal Beacons too, so we can use that as is. If you have a different type of beacon, a google search should help you get the right parser layout.
5. Bind to the BeaconManager. This is what starts off the process.
6. Setup event handlers for the different notifiers.
7. Once the bind is done, you get a callback to OnBeaconServiceConnect which is part of your implementation of IBeaconConsumer
8. Here you setup other notifiers you maybe interested and regions etc. If you want to listen to all beacons, just setup an Empty Region with null for UUID etc. Else you can listen only for beacons you want to listen to by using specific UUIDs.
9. Then call StartMonitoringBeaconsInRegion to start the monitoring.
10. Once beacons are detected then the event handlers you had mapped get triggered. The beacons in range are passed via the RangeEvenArgs parameter of the event. You take the beacon data available and then do the required business action.

Technorati Tags: Xamarin,Android,iBeacon,AltBeacon,Development

IEquatable<T> – A Tough Interface to Implement Correctly

IEquatable<T> seems to be a simple enough interface to implement. It just has one method

1. public bool Equals(MyClass other)

That seems easy enough!! But once you get into all the rules around this, it is a minefield and needs to be implemented with a lot of care. Also information on how to implement this is spread all over the web and it is quite difficult to get all the data in one place.

You get an instance of the class as a parameter and you just compare other with the data you have in your current instance and return true or false.

Well, ok you have that code in place, how do you use it?

MyClass a, b;

// Code that setup data for MyClass instances
//

MyClass.Equals(a, b);

 

You think this should work? Well it will not give you any errors, but your Equals function is not called? Why, because this calls the Object.Equals method, rather than your equals (so you are actually doing a Reference equality rather than your custom logic). The way to call the IEquality.Equals (as defined above) is

 

a.Equals(b);

 

Well, that’s why the MSDN topic on IEquatable clearly states:

If you implement IEquatable<T>, you should also override the base class implementations of Object.Equals(Object) and GetHashCode so that their behavior is consistent with that of the IEquatable<T>.Equals method. If you do override Object.Equals(Object), your overridden implementation is also called in calls to the static Equals(System.Object, System.Object) method on your class. In addition, you should overload the op_Equality and op_Inequality operators. This ensures that all tests for equality return consistent results.

This is to ensure that Object.Equals, Instance.Equals, == and != all work in the same way and the you don’t have unintentional side effects.

I prefer to write a static check method that can be called from all the overrides. Again writing a equality function is more complicated than it sounds. A rough template of my equality check is as below

public static bool EqualsCheck(MyClass a, MyClass b)

{

    //Check 1

    //If both are the same instance of an object then return true

    //Object reference also returns true if both objects are null

    if (object.ReferenceEquals(a, b))

return true;

 

    //Check 2

    //IF one of the object is null and

    //the other not null, then equality fails

    if (a == null ^ b == null)

return false;

 

    //Check 3

    // Actual logic to check equality of the two objects

}

Once all the overrides are wired up for Equality, you still have one override still left. That of GetHashCode. This is a tricky item as it has some strict rules that have a direct impact on usage in any Hashed collection.

If you have an property/field that will not change during the lifetime of this class, then you can just use the GetHashCode of that property and return that. Also you need to ensure that this property is not changed via maybe a private set/readonly setting.

If you don’t want to get into implement your own Hash Algorithm, then return 1. This follows all the rules, but has a performance impact when this class is part of hashed collection (e.g. Dictionary).

Also there are some gotchas to be aware of using this in a base class. So the recommendation is to use this only on sealed classes. This post has the details on the problems using this in base classes.

So think twice and see if your class design really needs IEquatable and then ensure you implement it fully or you may end up with unforeseen and hard to debug bugs.

In the Mobile World - IV

This is part IV and final part of the series. Part I, II & III can be found here, here and here.

Ok, so what if you are a desktop .NET developer (XAML, C# or VB etc.) and web development is something you don’t want to do. Well Windows 8 modern/store apps still use XAML, something that WPF developers will be comfortable with. But as mentioned before, if you want to take your skills to other platforms, you need third party support.

Xamarin is a platform that allows you to write .NET code that will run on iOS and Android. They use the mono framework (a port of .NET to Linux) to enable this magic the happen.

Xamarin also takes an unique approach to cross platform development. It uses a platform specific view layer and the View Model, Model and lower layers (in a MVVM architecture) are reused. So if you need to use Xamarin, you do need knowledge of creating views using XCode (for iOS) or Ecllipse (for Android) using the native code. The VM obviously is impacted by the View itself, but the model and below is all .NET code.

So if you are a .NET desktop developer using WPF/SL or similar you are quite comfortable with MVVM and a lot of your skills will directly transfer to the mobile platforms using Xamarin.

 

 

Technorati Tags: Mobile,Cross Platform,Xamarin,.NET

Should you use your Banks Mobile app?

Well that is the question topmost on my mind when I read this new article from IOActive. This includes apps from banks in India too, but the name of the banks have not been revealed for security reasons. So do we assume the worst?

Personal banking apps leak info through phone

Some of the problems highlighted...

• All of the applications could be installed on a jail broken iOS device. This helped speed up the static and black box analysis.
• 40% of the audited apps did not validate the authenticity of SSL certificates presented. This makes them susceptible to Man in The Middle (MiTM) attacks.
• A few apps (less than 20%) did not have Position Independent Executable (PIE) and Stack Smashing Protection enabled.
• Many of the apps (90%) contained several non-SSL links throughout the application. This allows an attacker to intercept the traffic and inject arbitrary JavaScript/HTML code in an attempt to create a fake login prompt or similar scam. 
• It was found that 50% of the apps are vulnerable to JavaScript injections via insecure UIWebView implementations. In some cases, the native iOS functionality was exposed, allowing actions such as sending SMS or emails from the victim’s device.
• 70% of the apps did not have any alternative authentication solutions, such as multi-factor authentication, which could help to mitigate the risk of impersonation attacks.
• 20% of the apps sent activation codes for accounts though plaintext communication (HTTP)

 

Technorati Tags: Security,Banks,Mobile Banking

In the Mobile World - III

This is part II of the series. Part I & II can be found here & here.

Ok using HTML5/CSS3/JS creating mobile websites is easy. But what if you want to go beyond and create app.

Well then you need to go for some third party support.

If you are a company/have money to spend, you can try out something like http://www.orubase.com/ from Syncfusion. This allows you to take your ASP.NET MVC skills and create native apps for multiple platforms. Also it provides native JS bridges which means you can also use device features like camera, GPS etc. in you application. Your HTML5/ASP.NET MVC code gets wrapped into a native application. Also since Syncfusion is a UI components company, Orubase includes a number of UI components that you can use to build your apps.

 

If you are a hobbyist, then you can always go for Cordova (aka Phonegap). This does mostly what Orubase does, except it take pure HTML5/JS/CSS3 and not ASP.NET MVC. Cordova is an Apache open source now and you can

You will still need to learn APIs specific to these platforms, but these are usually easy to learn JS libraries in most cases.

In the Mobile World - II

This is part II of the series. Part I can be found here.

Ok, so you want to target multiple mobile OSes and not restrict yourself to Windows 8. Well if you are a web developer you already have a head start. HTML5 is the hot new kid on the block and almost all mobile browsers support part of the HTML5 spec (well HTML5 is not yet a standard, so what is supported is completely arbitrary, but seems like the different mobile browsers support enough in common to be usable).

So basically creating a mobile enabled site is something that is happening quite a bit and you already have a number of skills that will feed into this. Learning new features in HTML5/CSS3 will be needed, but you already have the skillsets required in the server side, i.e. ASP.NET. Also you have the basic JavaScript and JQuery skills (hopefully), but can extend it to mobile versions like JQuery mobile.

Also there are a number of other JS libraries that are used quite extensively now, not specifically only for mobile, so it would make sense for you to extend your skillset to stuff like AngularJS, node.js or DOJO.

So using HTML5/CSS3/JS and ASP.NET skills you can build websites that are optimized for the mobile. Also ASP.NET MVC4 has device features that will allow you to have views specific to different devices and thus render a special view based on the device used to browse.

 

The only gotcho in this approach is that your web site remains a website and you would access it via the browser on the mobile device. As users get more accustomed to devices, the requirement/expectation of using an app rather than launching a browser is increasing.

Also some device specific features like camera, push notifications etc., are not usable from a pure web application.

In the Mobile World - I

This is a series of blog post I wanted to write aimed at .Net developers and how mobility has an impact on the skills you have. I am not sure how many posts I will write in this series, but initially I think there will be at least 2-3. So here goes…

Say you are a .NET developer and have built skills over the past couple of years around either the web or the desktop development platforms. So you have spent time to build skills around C#/VB, .NET framework, SQL Server and maybe even WCF which are common across different development platforms that make up the Microsoft stack.

Now you have been hit by the mobility wave and you are at a cross road. What can you do? Do you take the easiest option and upgrade your skills to WindowsRT (the new .NET framework derivative that is part of Windows 8 Metro Modern Apps) or abandon ship and move to the other more successful mobile platforms like iOS/Android etc. Obviously if you had been a Java developer the path to Android is quite easy, but do you want to abandon the years you spent building your .NET skills and jump ship?

Well this post start off with the easiest option. Moving your skills to WindowsRT. This is an absolute child’s play for people who have been working WPF/Silverlight platforms because your XAML skills come into play directly. You will still have to learn the new UX design language and the constraints that WinRT puts, but it is a simple path to take. The biggest challenge I see people facing is not usually from the UX design, but rather understanding the things they cannot do. E.g. if you are trying to do complex stuff around encryption, then the WinRT limited support for the cryptography namespace can literally may you tear you hairs out..:)

If you are on the web side of development, then WinRT still is an option, as you can move your HTML/JS skills over using the HTML5/JS approach to build Modern apps. Again there is some skill building needed, but still I think it is quite an easy upgrade curve for your skills.

The other gotcho here is that Windows8 and Windows Phone8 are still not on the same development platform. So you will have to build extra skills (it is not only the UI/form factor changing like in iOS/Android, but the APIs/platform themselves changing) if you need to target both tablets and phones on the windows platform. Again something that may get solved as the two platforms integrate and unify sometime in the future (nobody knows for sure when though).

The only problem with the easy approach, is that it is dependent on Windows 8 (your apps are not going to run on Win7 machines, nor or on other mobile platforms). So this is dependent on Windows8 being successful in the mobile space and that is a tough call as of now. Even though the number of Win8 licenses being sold maybe increasing and you are seeing new tablet devices out there, these are nowhere near getting a big enough market share in the near future to dethrone any of the existing leaders.

If the enterprise you are with is going to adopt Window8 or WP8, then this is the easiest skill upgrade path for you to get into the mobile world.