Summary: When a client adds a service reference to a service, the generated classes are marked as partial, which lets the client add additional helper methods and local functionality to the classes.

When a client generates a contract from a service, only the data and method signatures are included (and not the method implementation). The constructor is not part of the contract either. Here’s an example:

The service, running in Windows Azure, defines a LatLongLocation contract. It looks like

The contract (as defined by the service) has a constructor to make it easy (for the service) to construct this object, however this constructor is never sent over the wire. When a client consumes this contract (by adding a reference to the service), only the data members (and method signatures) are generated (see below). Pay special attention to the fact that this is a partial class, which will be useful later on for the client.

    [System.Runtime.Serialization.DataContractAttribute(Name="LatLongLocation", Namespace="http://schemas.datacontract.org/2004/07/PresenceService")]
    [System.SerializableAttribute()]
    public partial class LatLongLocation : object, System.Runtime.Serialization.IExtensibleDataObject, System.ComponentModel.INotifyPropertyChanged {
       
        [System.Runtime.Serialization.OptionalFieldAttribute()]
        private double LatitudeField;
       
        [System.Runtime.Serialization.OptionalFieldAttribute()]
        private double LongitudeField;
       
        [System.Runtime.Serialization.DataMemberAttribute()]
        public double Latitude {
            get {
                return this.LatitudeField;
            }
            set {
                if ((this.LatitudeField.Equals(value) != true)) {
                    this.LatitudeField = value;
                    this.RaisePropertyChanged("Latitude");
                }
            }
        }
       
        [System.Runtime.Serialization.DataMemberAttribute()]
        public double Longitude {
            get {
                return this.LongitudeField;
            }
            set {
                if ((this.LongitudeField.Equals(value) != true)) {
                    this.LongitudeField = value;
                    this.RaisePropertyChanged("Longitude");
                }
            }
        }

    }

The client wants to consume the LatLongLocation contract. The client is a program running on a laptop with a GPS sensor. It can use the Windows 7 location platform to get the current location and then send it to the Azure service. The location platform returns data as a  LatLongLocationReport and this needs to be converted into a LatLongLocation so the service can consume it.

The client program has added a reference to the Azure service. The service metadata is downloaded when adding a reference using Visual Studio and the contract is generated from it. To the client code, the following partial class is added as a convenience to construct LatLongLocation objects.

    // The LatLongLocation type is defined by the Presence Service, but
    // the generated reference to the service only contains data members (by design).
    // This adds a new type of constructor to use with data from
    // the Win7 location platform.
    public partial class LatLongLocation
    {
        public LatLongLocation(Windows7.Location.LatLongLocationReport report)
        {
            this.Latitude = report.Latitude;
            this.Longitude = report.Longitude;
        }
 
        public LatLongLocation(double latitude, double longitude)
        {
            this.Latitude = latitude;
            this.Longitude = longitude;
        }
    }

(Note that the LatLongLocation (latitude, longitude) constructor is duplicated from the service definition out of necessity and is only added as a convenience for the client-side code. In fact the client may not even be aware that the same constructor ever existed on the service-side).

This shows a client can add additional local functionality (LatLongLocationReport) to the service-side defined contract (LatLongLocation). The functionality added on the client side won’t be sent over the wire and affect the service either. In addition, if the generated contract ever needs to be regenerated, it won’t wipe out the additional code added on the client-side.

Ever see “FaultException: authN failed: ‘…’ of PasswordCredential” when trying to call a method that uses Windows Azure and the Access Control Service? The issue is simply that the password is not correct.

For example, here’s a snippet of a client trying to call a method in a Windows Azure service (“MyEndpoint”), which will throw the FaultException. (Assume that my solution name is “PineCreek”, and my Live Id account for the ACS control panel is timber@example.com).

ServiceClient proxy = new ServiceClient("MyEndpoint");
proxy.ClientCredentials.UserName.UserName = "PineCreek";
proxy.ClientCredentials.UserName.Password = "badpassword";
proxy.DoMethod(); // this will throw FaultException: authN failed

As shown, the the wrong password was entered. The user name and password used here is the same as the .NET Services solution name and password (which is also different than the Live ID used to log in to the Access Control Service control panel).

The fixed code is as follows:

ServiceClient proxy = new ServiceClient("MyEndpoint");
proxy.ClientCredentials.UserName.UserName = "PineCreek";
proxy.ClientCredentials.UserName.Password = "ValidPassword";
proxy.DoMethod(); // this will now succeed

(Again, this also shows that the Live Id account doesn’t get used in the code).

Note: the Access Control Service credential management page is at https://accesscontrol.ex.azure.microsoft.com/ManageAccount.aspx

For reference, the exception is as follows:
System.ServiceModel.FaultException was unhandled
Message="authN failed: 'PineCreek' of PasswordCredential (#6a4d0ffb-4c3b-1cd8-d284-11660ae4cb08)"
Source="mscorlib"
Action="http://www.w3.org/2005/08/addressing/soap/fault"
StackTrace:
Server stack trace:
at System.ServiceModel.Security.IssuanceTokenProviderBase`1.DoNegotiation(TimeSpan timeout)
at System.ServiceModel.Security.IssuanceTokenProviderBase`1.GetTokenCore(TimeSpan timeout)
at System.IdentityModel.Selectors.SecurityTokenProvider.GetToken(TimeSpan timeout)

Overview

Windows has an entire API for text input and interaction.

The Text Services Framework (TSF) is a COM framework and API that supports advanced text input and text processing. It is designed to offer advanced language and word processing features to applications. It supports features such as multilingual support, keyboard drivers, handwriting recognition, speech recognition, as well as spell checking and other text and natural language processing functions.

Architecture

The diagram is below but please see the details at http://msdn.microsoft.com/en-us/library/ms538050(VS.85).aspx

Using TSF

TSF can be implemented as an app or as a text service.

For a keyboard, we’d be writing a TSF text service.

• A text service can obtain text from, and write text to, an application. A text service can also associate data and properties with a block of text. A text service is implemented as a COM in-proc server that registers itself with TSF. When registered, the user interacts with the text service using the language bar or keyboard shortcuts. Multiple text services can be installed.
• TSF-aware apps can provide the input context or scope (e.g. “url”, “name”, “address”)

On the app side, extensibility is done by the app by implementing interfaces and registering them with TSF.

TSF can read the current "context" from the application, which . The "context" is the characters on the screen around the insertion point.

TSF and Managed Code:
Difficult since text service gets loaded into arbitrary processes, so they need to be small and lightweight, among other reasons. http://blogs.msdn.com/tsfaware/archive/2007/04/19/tsf-and-managed-code.aspx

Legacy apps:
TSF has a table of controls for legacy apps that describes the input scope (e.g. the address bar control in IE5 takes a “url”)

Other notes:
The Tablet PC TIP uses TSF to provide text to apps.

References

• TSF on MSDN: http://msdn.microsoft.com/en-us/library/ms629032(VS.85).aspx
• Text Services Framework blog: http://blogs.msdn.com/tsfaware/Default.aspx?p=2
• Walkthrough on making an app work with TSF: http://msdn.microsoft.com/en-us/magazine/cc187238.aspx

jk on the Run points to a video review of the Media Center gadgets for Windows SideShow:http://www.jkontherun.com/2008/11/windows-mobil-1.html

Have feedback about the gadgets? Please get in touch and let us know.

Is it possible to bind properties to a MarkupExtension that returns a Binding? Yes! The MarkupExtension just needs to return a BindingExpression by returning binding.ProvideValue(serviceProvider):

    [MarkupExtensionReturnType(typeof(BindingExpression))]

    public class PhysicalLengthMarkupExtension : MarkupExtension

    {

        public override object ProvideValue(IServiceProvider serviceProvider)

        {

            Binding physicalLengthBinding = new Binding();

            physicalLengthBinding.Source = _dpiProvider;

            physicalLengthBinding.Path = new PropertyPath("DPI");

            physicalLengthBinding.Converter = _dpiConverter;

            physicalLengthBinding.ConverterParameter = _length;

            return physicalLengthBinding.ProvideValue(serviceProvider);

        }

    }

Which enables the ability to write

<TextBlock Width="{Markup:PhysicalLengthMarkupExtension 3cm}"/>

instead of the more verbose and redundant

        <TextBlock>

            <TextBlock.Width>

                <Binding

                  Source="{StaticResource DpiProvider}"

                  Path="DPI"

                  Converter="{StaticResource DpiConverter}"

                  ConverterParameter="2in"

                  />

            </TextBlock.Width>

        </TextBlock>

Trying to hide your forms window? Here are a couple sample solutions:

One cumbersome solution is to override WndProc, listen for any window position changing messages (which includes z-order), and then not pass any show window flag on.

public class MyForm : Form
{
    public MyForm()
    {
        // Ensure that this is a hidden window
        this.WindowState = FormWindowState.Minimized;
        this.ShowInTaskbar = false;
        this.FormBorderStyle = FormBorderStyle.None;
    }

    protected override void WndProc(ref Message m)
    {
        const uint WM_WINDOWPOSCHANGING = 0x0046; // WinUser.h
        const uint SWP_SHOWWINDOW       = 0x0040; // WinUser.h

        if (m.Msg == WM_WINDOWPOSCHANGING)
        {
            // Ensure the window is hidden by consuming any "show window" requests
            // (which can happen when pressing alt+tab)
            Win32Api.WINDOWPOS windowPos = (Win32Api.WINDOWPOS)Marshal.PtrToStructure(m.LParam, typeof(Win32Api.WINDOWPOS));
            windowPos.flags &= unchecked(~SWP_SHOWWINDOW);
            Marshal.StructureToPtr(windowPos, m.LParam, true);
            m.Result = (IntPtr)0;
        }

        base.WndProc(ref m);
    }
}

The better solution is to simply make the window not visible after it finishes loading:

public class MyForm : Form
{
    public MyForm()
    {
        // Ensure that this is a hidden window
        this.WindowState = FormWindowState.Minimized;
        this.ShowInTaskbar = false;
        this.FormBorderStyle = FormBorderStyle.None;

        this.Load += new EventHandler(MyForm_Load);
    }

    void MyForm_Load(object sender, EventArgs e)
    {
        this.Visible = false;
    }
}