For example, you can use standard .NET formatting such as currency and date:

<TextBlock Text="{Binding Amount, StringFormat={}{0:C}}"/>
<TextBlock Text="{Binding Date, StringFormat={}{0:dd/MM/yyyy}}"/>

The empty {} after the StringFormat= escapes the text before the formatting string.

You can add text in front of the formatting string too, e.g.
StringFormat=Amount: {0:C}
in which case you don’t need to escape the string with the {}.

More advanced formatting options can be acheived using a multi-binding, for example:

<TextBlock>
  <TextBlock.Text>
    <MultiBinding StringFormat="Date {0} Time {1}">
      <Binding Path="DueDate" />
      <Binding Path="DueTime" />
    </MultiBinding>
  </TextBlock.Text>
</TextBlock>

However, there are occasions when you want to hide methods from external consumers for good reason, but still need to unit test them.  For example, producing a library to distribute to third-parties.

To do this with .NET you can mark the assembly with InternalsVisibleTo and specifiy the public key of the project allowed to view your internals.

For example, I have a project called MyNewProject and a project containing units tests for this called MyNewProjectTests, I can add the following code to the assembly.cs file in MyNewProject with the public key of the test project:

[assembly: InternalsVisibleTo("MyNewProject, PublicKey=0024...")]

Note, I’ve not included the entire public key here.

Now the internal methods are visible to the test project we have one more task. The unit test frameworks Rhino Mocks and Moq use a proxy class called DynamicProxyGenAssembly2 to represent your object when testing. We therefore need to expose the internals to this class also. We do this in the same way with another entry in the assembly.cs file:

[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024")]

<EditText
...
android:singleLine="true"
android:inputType="numberDecimal"
...
>

Then use, for example, Double.parseDouble(…) to retrieve the value in code.

Incidentally, the documentation recommends avoiding floats and using double instead.

...res\layout\main.out.xml:1: error: Error parsing XML: no element found

This occurs when you try and run the application from the main.xml layout file. The application cannot run from here and needs to be run from the java file.

The answer is to ensure that a java file is selected when you hit run, as you should run the java not the xml file.  The easiest way to ensure you don’t do this is to use the Run History options in Eclipse.

AddressAccessDeniedException

with the error message

HTTP could not register URL http://+:80/. Your process does not have access rights to this namespace (see http://go.microsoft.com/fwlink/?LinkId=70353 for details)

The Microsoft site (http://go.microsoft.com/fwlink/?LinkId=70353) does have a solution to the problem using httpcfg and netsh. However the far simpler solution is to run Visual Studio as Administrator

You can do that by right-clicking the shortcut for Visual Studio and selecting Run as adminstrator, or to permanently run as Administrator, right-click and select Properties. Find the Compatibility tab and check the Run this program as administrator checkbo€x.

public byte[] imageToByteArray(Image imageIn)
{
    MemoryStream ms = new MemoryStream();
    imageIn.Save(ms,System.Drawing.Imaging.ImageFormat.Gif);
    return ms.ToArray();
}
and conversely, turning a byte array into an image:

public Image byteArrayToImage(byte[] byteArrayIn)
{
    MemoryStream ms = new MemoryStream(byteArrayIn);
    Image returnImage = Image.FromStream(ms);
    return returnImage;
}


Anyhow, this worked fine on my XP machine but not on my Windows 7 machine.  The solution would compile, but when I tried to instantiate the control I received the following error in Visual Studio:

Class not registered (Exception from HRESULT: 0x80040154 (REGDB_E_CLASSNOTREG))

On the line:

((System.ComponentModel.ISupportInitialize)(this.myControl)).EndInit();

The reason was that the Windows 7 machine is 64-bit, while the XP one was 32-bit.  The projects in the solutions need to be built to target the x86 platform.  This is an option on the project properties, found from:

Project -> Properties -> Build -> Platform Target

First, delete the two code behind files. 

Second, you need to alter the page header to remove the references to the codefile and alter the inherits.

Change the standard file from:

<%@ Master Language=”C#” MasterPageFile=”~/Views/Shared/Site.master” AutoEventWireup=”true” CodeFile=”Normal.master.cs” Inherits=”Master_Normal” %>

To the following:

<%@ Master Language=”C#” MasterPageFile=”~/Views/Shared/Site.master” Inherits=”System.Web.Mvc.ViewMasterPage” %>

The SQL Server Management Studio allows you to run your scripts in ’sqlcmd mode’ in the query window.  This allows you to take advantage of the syntax colour coding and variables, while developing and testing sqlcmd scripts.  By default it is turned off, but you can enable it from the ‘Query’ menu for a specific query window.

One important thing to remember about using sqlcmd, is that it uses OLEDB, while Management Studio users the .NET SqlClient.  It is possible, therefore, to obtain different results when the scripts are actually run with sqlcmd at the command line.

This is because the “GO” statements cannot be executed within the script. The simple way around this is to break the script into parts by splitting the string on the “GO” statements. Then you can execute the individual commands.

Some sample code:

using(SqlConnection connection = new SqlConnection(connectionString))
{
  string[] commands = sql.Split(new string[]{"GO\r\n", "GO ", "GO\t"},
              StringSplitOptions.RemoveEmptyEntries );
  foreach (string c in commands)
  {
     command = new SqlCommand(c, connection);
     command.ExecuteNonQuery();
  }}