Enzo Contini Blog

The Microsoft Bot Framework is now in preview and it seems very interesting: it is what you need to build and connect intelligent bots that interact naturally wherever your users are talking, from text/sms to Skype, Slack, Office 365 mail, Facebook Messenger and other popular services. It enables organizations to build intelligent agents, known as Bots, that can interact with a requesting user. The primary interface for these experiences is email, text or voice. Conversation-driven UI can help to handle a conversation for grabbing a taxi, paying the electric bill, sending money to a friend, choose the sandwich you want or whatever.

If you want to know more about it you can follows the following links:

• What is Microsoft Bot Framework Overview
• Bot Framework FAQ
• Get started

Programmatically you can also send a message to a user, knowing his  conversation id and to send “not explicitly requested” messages you must go through the Bot Connector: http://docs.botframework.com/connector/replying; http://docs.botframework.com/connector/new-conversations/#navtitle

Snippets are very useful to speed up the code writing. Template10 have defined a lot of them specific for writing code using that template. In the following there are the simple steps you have to do to install them in your Visual Studio.

1. Download Template10 code from the GitHub repository of the Template10 project. I suggest you to use TortoiseGit client (that can be easily be used also if you have to possibly synchronize branches, even though this is not our case now, because we are going to clone the trunk).
   

   Clone Template10 solution

2. Import the snippets available in the Snippets directory of the Template10 solution using the Tools -> Code Snippet Manager. For your convenience, you can first create a specific T10 Snippets folders in both C:\Users\YourName\Documents\Visual Studio 2015\Code Snippets\Visual C#\My Code Snippets\T10 Snippets and C:\Users\YourName\Documents\Visual Studio 2015\Code Snippets\XAML\My XAML Snippets so you can import the snippets, the C# and XAML ones, in that specific directories. All the T10 snippets start with T10, so you can conveniently type that string to let them all be listed: then you can select the desired one and, as usually for snippets, press tab button to make the code be inserted and then possibly be modified.
   

   Import T10 snippets into Visual Studio 2015

    

If you want to create your own snippets you can have a look to Code Snippets and Adding Snippets to Visual Studio Code.

In this ongoing post, I will add more and more tips and useful links to better understand some topics related to C# …

• Value Types vs Reference Types
• Casting: “as ClassName” vs (ClassName)
• Enum
• Asynchronous Programming with Async and Await
• Navigation in an XML to get the attribute value of a node
• Lambda expressions/statement
• Visual Studio snippets
• Size of both references and data types

===================================================

Value Types vs Reference Types

Both primitive types (such as int, float, bool and char) and Structs are value types, while classes are reference types.

When a value-type instance is created, a single space in memory is allocated to store the value. When the runtime deals with a value type, it’s dealing directly with its underlying data and this can be very efficient, particularly with primitive types.

With reference types, on the contrary, an object is created in memory, and then handled through a separate reference—rather like a pointer.

This is of particular interest when passing parameters to methods. In C#, parameters are (by default) passed by value, meaning that they are implicitly copied when passed to the method. For value-type parameters, this means physically copying the instance, while for reference-types it means copying a reference.

See this link for examples and more details.

===================================================

Casting: “as ClassName” vs (ClassName)

With the “classic” method, if the cast fails, an exception is thrown. With the as method, it results in null, which can be checked for, and avoid an exception being thrown.

Because the as method can only be used for types that can be assigned a null value, usually, you can only use “as” with reference types while, if you are typecasting to a value type, you must still use only the “classic” method, unless it is a nullable value type: infact when .NET 2.0 came out, it introduced the concept of a nullable value type and since these types can be assigned a null value, they are valid to use with the as operator.

SomeClass someObject = (ClassName) obj; //it throws a class cast exception if obj isn't that ClassName

one can use this syntax:

ClassName someObject = obj as ClassName; //it returns null if obj isn't that ClassName

===================================================

Enum

Enums are strongly typed constants. They are essentially unique types that allow you to assign symbolic names to integral values. In the C# tradition, they are strongly typed, meaning that an enum of one type may not be implicitly assigned to an enum of another type even though the underlying value of their members are the same. Along the same lines, integral types and enums are not implicitly interchangable. All assignments between different enum types and integral types require an explicit cast.

You can find a good tutorial here.

public enum TipoTimbratura {Uscita = 0, Entrata = 1}

//poi nella classe che la usa:
TipoTimbratura tipo = TipoTimbratura.Entrata;

String tipoString = tipo.ToString(); //assegna la stringa "Entrata"

if (tipo ==TipoTimbratura.Entrata){...}

//per creare l'enum a partire da una stringa che ne è il valore:
TipoTimbratura tipo = (TipoTimbratura)Enum.Parse(typeof(TipoTimbratura), Uscita");

//per creare l'enum a partire dall'int
TipoTimbratura tipo = (TipoTimbratura)tipoInt;

//per avere la stringa a partire da un enum:
Enum.GetName(typeof(TipoTimbratura), tipo);//restituisce la stringa "Uscita"

//se si vuole ciclare su tutti i valori numerici:
foreach (byte val in Enum.GetValues(typeof(TipoTimbratura))) {...}

//se si vuole ciclare su tutti i valori stringa:
foreach (string tipo in Enum.GetNames(typeof(TipoTimbratura))) {...}

//inoltre per prendere il valore numerico sapendo la stringa:
int value = (int)TipoTimbratura.Uscita; //restituisce l'intero 0
int tipoInt = Int32.Parse("Entrata"); //restituisce l'intero 1

enum Direction {
	North,
	East,
	South,
	West
}

foreach (string direction in Enum.GetNames(typeof(Direction))) {
	Console.WriteLine("Direction Member: {0}\n Value: {1}",
	direction, (int)Enum.Parse(typeof(Direction), direction));
}
value = Convert.ToInt64(WrState.Dispatched)

===================================================

Asynchronous Programming with Async and Await

One of the more powerful (and not so easy to be understood) approach for the async programming in C# (.NET Framework  and the Windows Runtime) is the use of the async and await keywords.

This article (C#) from the MSDN site can be very useful to a first understanding what happens in an async method.

async (C# Reference) / await (C# Reference)

Video:

Six Essential Tips For Async – Introduction

1. Async void is for top-level event-handlers only, and event-like things. Don’t use it elsewhere in your code.
2. It’s crucial to distinguish CPU-bound work (should be done on threadpool) from IO-bound work (which needn’t).
3. You can wrap events up in Task-returning APIs and await them. This can dramatically simplify code.
4. Async library methods shouldn’t lie: they shouldn’t use Task.Run internally in secret, and should expose an async signature if and only if their implementation is asynchronous
5. Async library methods should have chunky async APIs not chatty. But if chatty is unavoidable, know about these micro-optimizations to reduce heap allocation overheads.
6. Async library methods should consider task.ConfigureAwait(false) to reduce their impact on the UI message queue.

Tip 3: Wrap events up in Task-returning APIs and await them

Async Programming Improvements for C++ and UWP

===================================================

Example: resolve all GeoCoordinates that are missing in a list of objects that contains also the address of the location and return the list with all the GeoCoodinates possibly valorized

 private async Task SetExchangeStopGeoCoordinate() {
            int found = 0;
            try {
                ExchangeStopList exchangeStopList = ((MissionDataSource)DataContext).Mission.ExchangeStops;
                List<Task> tasks = new List<Task>();
                int i = 0;
                foreach(var exchangeStop in exchangeStopList) {
                    if(exchangeStop.GeoLocation.GeoCoordinate == null) {
                        //GeoCoordinates are not valorized so they should be deduced from the address field
                        try {
                            Task task = exchangeStop.GeoLocation.ResolveCoordinates(((MissionDataSource)DataContext).MyGeoCoordinate);
                            tasks.Add(task);
                        } catch(Exception ex) {
                            MessageBox.Show(LocalizedStrings.GetString(ex.Message), LocalizedStrings.GetString("ExceptionCaption"), MessageBoxButton.OK);
                        }
                    }
                    if(exchangeStop.Description == null) {
                        exchangeStop.Description = i++.ToString(CultureInfo.InvariantCulture);
                    }
                }
                if(tasks.Count > 0) {
                    App.RunProgressBar(this, true, String.Format(LocalizedStrings.GetString("ResolveCoordinates"), tasks.Count));
                    await Task.WhenAll(tasks);
                    foreach(var task in tasks) {
                        bool resultFound = await task;//exchangeStopList[i].GeoLocation.GeoCoordinate = await task;
                        if(resultFound) {
                            found++;
                        }
                    }
                }
                App.RunProgressBar(this, false); //coordinate risolte
            } catch(UnauthorizedAccessException) {
                MessageBox.Show(LocalizedStrings.GetString("LocationDisabled"));
            } catch(Exception ex) {
                // Something else happened while acquiring the location.
                MessageBox.Show(ex.Message);
            }
            return found;
        }

 public  async Task ResolveCoordinates(GeoCoordinate myGeoCoordinate ) {
            StringBuilder sbSearchTerm = new StringBuilder();
            sbSearchTerm.Append(((this.Street != null) ? (this.Street) : ""))
              .Append(((this.Number != null) ? (" " + this.Number) : ""))
              .Append(((this.City != null) ? ("," + this.City) : ""))
              .Append(((this.Zip != null) ? ("," + this.Zip) : ""))
              .Append(((this.Country != null) ? ("," + this.Country) : ""));
            string searchTerm = sbSearchTerm.ToString();
            var geocodeQuery = new GeocodeQuery {
                SearchTerm = searchTerm,//"Ferry Building, San-Francisco"//"46 Anglesea St, Auckland"
                GeoCoordinate = myGeoCoordinate == null ? new GeoCoordinate(0, 0) : myGeoCoordinate //GeoCoordinate = _myGeoCoordinate == null ? new GeoCoordinate(0, 0) : _myGeoCoordinate
            };
            int retry = 2;
            IList mapLocations = null;
            while(retry > 0 && (mapLocations == null || mapLocations.Count == 0)) {
                try {
                    mapLocations = await geocodeQuery.ExecuteAsync(); //var locations = await geocodeQuery.ExecuteAsync();
                } catch(Exception ex) {
                    MessageBox.Show("Exception: " + ex.Message);
                }
                retry--;
            }

            if(mapLocations != null && mapLocations.Count > 0) {
                if(mapLocations.Count == 1) {
                    this.GeoCoordinate = mapLocations.First().GeoCoordinate;
                    if(this.GeoCoordinate == null) {
                        //anche se è strato trovato, le GeoCoordinate non sono fornite
                        return false;
                    }
                    return true;
                } else {
                    //sono state trovate più corrispondenze: chiedere all'utente quale scegliere (per default la prima)

                    //http://stackoverflow.com/questions/12858501/is-it-possible-to-await-an-event-instead-of-another-async-method
                    TaskCompletionSource continueClicked = null;
                    DataTemplate dataTemplate = CreateDataTemplate();
                    List locationList = new List();
                    for(int i = 0; i  {
                        if(streetListPicker.ListPickerMode == ListPickerMode.Expanded) {
                            e1.Cancel = true;
                        } else if(streetListPicker.ListPickerMode == ListPickerMode.Full) {
                            e1.Cancel = true;
                            messageBox.Visibility = Visibility.Collapsed;
                            //????? TODO non funziona https://phone.codeplex.com/workitem/11357
                            streetListPicker.IsEnabled = true;
                            streetListPicker.Visibility = Visibility.Visible;
                            streetListPicker.Focus();
                            streetListPicker.UpdateLayout();
                        }
                    };
                    messageBox.Dismissed += (s2, e2) => {
                        switch(e2.Result) {
                            case CustomMessageBoxResult.LeftButton: {
                                    // save the choosen MapLocation
                                    int selectedIndex = streetListPicker.SelectedIndex;
                                    this.GeoCoordinate =
                                        mapLocations.ElementAt(selectedIndex).GeoCoordinate;
                                    if(this.GeoCoordinate == null) {
                                        //anche se è stato trovato, le GeoCOordinate non sono fornite
                                        if(continueClicked != null)
                                            continueClicked.TrySetResult(false);
                                    } else {
                                        if(continueClicked != null)
                                            continueClicked.TrySetResult(true);
                                    }

                                    break;
                                }
                            case CustomMessageBoxResult.RightButton:
                            case CustomMessageBoxResult.None: {
                                    // scelgo di default il primo (dovrebbe essere il più probabile, vicino alla mia posizione
                                this.GeoCoordinate = mapLocations.First().GeoCoordinate;
                                if(this.GeoCoordinate == null) {
                                        //anche se è strato trovato, le GeoCoordinate non sono fornite
                                        if(continueClicked != null) {
                                            continueClicked.TrySetResult(false);
                                        }
                                    }
                                    if(continueClicked != null) {
                                        continueClicked.TrySetResult(true);
                                    }
                                    break;
                                }
                            default:
                                break;
                        }
                    };
                    streetListPicker.SelectionChanged += (s3, e3) => {
                        if((streetListPicker.ListPickerMode == ListPickerMode.Full)) {
                            messageBox.Visibility = Visibility.Visible;
                        }
                    };
                    messageBox.Show();
                    continueClicked = new TaskCompletionSource();
                    bool b = await continueClicked.Task;
                    return b;
                }
            } else {
                return false;
            }
        }

===================================================

Navigation in an XML to get the attribute value of a node:

Solution 1: using XElement from System.Xml.Linq namespace

XElement sheet = XElement.Parse(MyXml);
var temp = sheet.Descendants(sheet.Name.Namespace + "<searched node>");
XElement x = temp.FirstOrDefault();

where x is a node element and then , through methods and properties, all the attributes can be accessed.

==================================

Solution 2: using XmlDocument

XmlDocument xdoc = new XmlDocument();
xdoc.LoadXml(xmlString);
var nodo = xdoc.GetElementsByTagName("myNodeName");
for (int i = 0; i < nodo.Count; i++) {
  var myChild= nodo.Item(i);
  for (int j = 0; j < myChild.ChildNodes.Count; j++) {
    var attributo = myChild["myAttributeName"];
  }
}

===================================================

Lambda expressions: [see Lambda Expressions (C# Programming Guide)]

A lambda expression is an anonymous function and it is mostly used to create delegates in LINQ. Simply put, it’s a method without a declaration, i.e., access modifier, return value declaration, and name.

Lambda basic definition: Parameters (if any) => Executed code

E.g.

(x, y) => x == y

Sometimes it is difficult or impossible for the compiler to infer the input types. When this occurs, you can specify the types explicitly as shown in the following example:

(int x, string s) => s.Length > x

Specify zero input parameters with empty parentheses:

() => SomeMethod()

Advantages:

1. Reduced typing. No need to specify the name of the function, its return type, and its access modifier.
2. When reading the code, you don’t need to look elsewhere for the method’s definition.
3. Run time advantages.
4. Allows to create  delegates or expression tree types

Statement Lambdas

(input-parameters) => { statement; }+

The body of a statement lambda can consist of any number of statements; however, in practice there are typically no more than two or three.

Async Lambdas

Lambda expressions and statements can incorporate asynchronous processing by using the async and await keywords.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        button1.Click += async (sender, e) =>
        {
            // ExampleMethodAsync returns a Task.
            await ExampleMethodAsync();
            textBox1.Text += "\nControl returned to Click event handler.\n";
        };
    }  

    async Task ExampleMethodAsync()
    {
        // The following line simulates a task-returning asynchronous process.
        await Task.Delay(1000);
    }
}

instead of

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }  

    private async void button1_Click(object sender, EventArgs e)
    {
        // ExampleMethodAsync returns a Task.
        await ExampleMethodAsync();
        textBox1.Text += "\r\nControl returned to Click event handler.\n";
    }  

    async Task ExampleMethodAsync()
    {
        // The following line simulates a task-returning asynchronous process.
        await Task.Delay(1000);
    }
} 

===================================================

Visual Studio snippet

• Default Code Snippets
• Code Snippet Functions
• Code Snippets
• How to: Create a New Snippet with Replacements
• Template Parameters
• How to: Use Surround-with Code Snippets
• How to: Restore C# Refactoring Snippets

By default the following code snippets are included in Visual Studio: after  writing shortcut, press twice tab hardware button.

The reference types (object references and pointers) are the size of a memory address, which would be 32 bits (4 bytes) on a 32-bit platform, and 64-bits (8 bytes) on a 64-bit platform.

All the other data types are defined by the language, not the CPU or OS.  See the reference chart below.

See http://msdn.microsoft.com/en-us/library/ms228360.aspx

If you navigate in the HERE site, you can read:

“If you have a smartphone with Windows 10:
In the last few months, we made the HERE apps compatible with Windows 10 by using a workaround that will no longer be effective after June 30, 2016. To continue offering the HERE apps for Windows 10 would require us to redevelop the apps from the ground up, a scenario that led to the business decision to remove our apps from the Windows 10 store.
This means the HERE apps will no longer work on devices running Windows 10 mobile after June 30, 2016. To prepare for this change, we have also decided to remove the HERE apps from the Windows 10 store on March 29, 2016.”

PLEASE LEAVE A COMMENT ON THAT POST … HERE executives must change their mind … I cannot believe that their employees like that stupid decision too and I hope they strongly react …

They say that they “made the HERE apps compatible with Windows 10 by using a workaround that will no longer be effective“… sorry, but – as a programmer – I know that every app that runs on Windows Phone 8 can run on Windows 10 Mobile too (not as a Universal Windows app, but anyway it is compatible). So please HERE,  be honest and at least … and do not say that you remove your apps from the Windows Store only because “you are now using a workaround to make them work that could not be effettive from now on” … You could decide not to do new releases, but removing now your apps from the Windows Store is ridiculous !!!
What is your business? Isn’t it related to have more clients installed everywhere to give and get information?
It may be true that, even though Windows Phone 8 apps are – in general – compatible with Windows 10 Mobile, HERE apps are not “normal” apps because they are very integrated with the operating system and should make use of internal API not available to “normal” developers. May be, that functionality set have been radically be modified in Windows 10 and the better way to improve those apps should be to rewrite them as Universal Windows app: it seems that they are not working with the latest build of Redstone, actually available only to the fast ring Insiders for the latest device models (Lumia 950 / Lumia 950 XL) …
BUT … if something will change in the future Redstone version of Windows 10 and so the HERE apps could not really work anymore …  WHY retire, till then, their now well running apps from the Windows 10 Store, do not giving to Microsoft at least more time to improve its Maps app that already does also navigation??

I still hope HERE executives change their mind … I cannot stand people that hope to make business trying to destroy the one of other companies!! I always was a supporter of HERE apps … please do not make me change my mind!!! This decision is really a hit below the belt and their executives that made that decision will be pointed out by every good guy, developers first of all, that have in mind the progress ot technology. HERE people, BE AWARE and change your mind! I think that NOKIA workers should react in some strong way to this position of their executives: with decision like this one, the fate of their company is clear…

Someone commented on that post “Ironically it is Microsoft that bought and then destroyed Nokia (from where HERE originated). Personally i hope this is a vindictive move“. But please … the fate of NOKIA, unfortunately, was already written at least two years before … may be Microsoft allowed that agony to continue for a while: but everyone have to admit that the real cause of the fate of NOKIA was, as it often occurs, of the narrow sight of the executives of that company that didn’t realize the big technical changes in the phone market. … and, believe me, I am very sorry for that, … I always bought NOKIA devices since the beginning and I always appreciate the design and solutions they found!

BUT, as the guy that did that comment supposes and as I personally think too, this is only one more vindictive move in the technology market … please God let those executives, that wants to make money on the dashes of other companies, get out of this world as soon as possible: the path towards the human progress do not need them at all!!

Anyway, we know that in Windows 10 there is already the Maps app that can substitute HERE apps in all Windows 10 devices, included the mobile one: it is a good Universal Windows app that included a lot of feature, included the navigation one … may be, in my opinion, it includes too many features in a single app, but it is a very good starting point as a navigator too. However, for the time being, the differences with HERE Drive (especially from the UI point of view) are still evident: sometimes ago I wrote a post comparing HERE Drive and Maps apps and the actual app release is not so different from the one I tested that time …

Maps: starting navigation

Maps: navigation

… the actual UI of Maps app is not so good, related to the navigation feature, I know  … but, I already said, it is a good starting point and you knows that apps can be update more and more and improve themselves … independently from the operating system updates.
Someone (always in a comment in the HERE site) complained about driving directions suggested by Maps app: at least for my experiences here in Italy, I did not find so much differences compared to HERE suggested ones. Sometimes in the past HERE Maps too let me go in very strange and unfair roads, as it may happen with every navigator, and I am really surprised that even hat guy in the past did not experiment that …

Yesterday there was a post in Windows Central talking about a new release of Maps app that will be distributed in a little time at least for Insiders. You can read there:

Speaking of built-in maps Microsoft is giving a bit of a tease about what is coming next to Insider builds for Windows 10 Mobile. In a commend on reddit, a Microsoft employee on the Maps team named Dave_MSFT gave a glimpse of what Insiders can expect in the near future:

“We have an exciting update coming soon to insider builds, including an improved drive mode. We will also be addressing other top feedback I have been collecting from you guys as well as the Windows Feedback app in this update and in updates to come. Stay tuned “

In a follow up comment, Dave expanded upon the news:

“Better drive UI is part of this initial update…We are exploring options around the arrow on the location marker (compass). Being able to search along the route is a great suggestion that I will bring back to the team. I will take your other feedback to the team as well!”

Microsoft’s native Maps app has made significant progress over the last few months in adding new features and many improvements. However, building an app from scratch that should have parity with the competition is no simple task and the company clearly has a lot of work left to do.

On their hand there is the fact that Microsoft included in Windows 10 everywhere  a way to get feedbacks from users … and also internally the Maps app have this feature and not only there is the Feedback app / Insider Hub app: HERE apps do not allows, as I know, this feature that can be very useful to improve the features that really are required by the end users …

The Store app is an Universal App … but it has a quite strange interface behavior!

You surely know that Universal Apps can change completely the user interface according mainly to the dimension of the screen but even possibly to the type of device (e.g. mobile, desktop) … and this is what happens in the Store app and may be, in this case, it can make you be confused and you can wonder how to force an app update check when it is running on a Windows 10 desktop device!!!

If you are used to Windows 10 Mobile, you know that there is a hamburger menu on the top left that shows a list with the specific item “Downloads and updates” for forcing that check: on the contrary, if you see that app on a PC (at least if it is in full screen mode or in a big windows!) you can’t see the hamburger icon on the upper left … and you may wonder how to do that!

Then, if you click on your user icon (on the top right) you can have the wanted menù appear … and possibly you may doubt that this app is really an Universal App being this behavior so different from the one you have on Windows 10 Mobile!

But if you dimension the window smaller enough, you can have your user icon disappear and the hamburger menu be shown … like it is in Windows 10 Mobile!!!

The same happens for Settings and others voice menu:

Every time you do a build, by default NuGet check and possibly download missing packages.

As stated in the output windows when making a build, if you want “To prevent NuGet from restoring packages during build, open the Visual Studio Options dialog, click on the Package Manager node and uncheck ‘Allow NuGet to download missing packages during build.’ “.

Because this check takes some time, during normal coding and rebuilding, you don’t need necessarily to have that default option set … and may be you want to disable it: obviously, the first time you build a project downloaded from a repository, you need to have that option enabled to make it compile correctly!

You can modify that option going to Tools -> NuGet Package Manager and then unchecking “Automatically check for missing packages during build in Visual Studio” (alternatively, you can go to Tools -> Options and then select the NuGet Package Manager section).

On the contrary, if your missing packages are not downloaded during a build, may be you have that option unchecked (by default it is checked  but you could have unchecked it and  you don’t remember …. 😉