Search results for 'app:weblogs' matching tag '.NET 3.5 Framework'

WF Persistence - Where [DataContract] != [Serializable]

William — Sat, 01 Nov 2008 05:00:00 GMT

Let's say you were using Workflow Foundation (WF) and Windows Communication Foundation (WCF). Assume you wanted to use WF's Persistence mechanism (which requires types to be Serializable). And assume that all the objects you were using in the workflow were decorated with the [DataContract] attribute. Would you expect any problems related to Serialization? (I can but to the chase really quickly here if you don't want my belabored background information and explanation. If you're creating a type to use w/ Workflow Foundation that will be saved via the Workflow Foundation Persistence Service which makes use of the SqlWorkflowPersistenceService class, marking the class as a [DataContract] alone will not work for WF's persistence mechanism. It does make the class serializable in a literal sense and will suffice [provided you meet the other requirements of a [DataContract] for WCF's serialization needs, but it is insufficient for WF (see the References section at the end of this post for more details on WF Serialization) - so make sure you use the Serializable attribute on any type that'll be consumed by the Persistence Service).

MSDN describes the DataContract class the following way:

Specifies that the type defines or implements a data contract and is serializable by a serializer, such as the DataContractSerializer. To make their type serializable, type authors must define a data contract for their type.

If you spend a lot of time in WCF, you'd likely assume that b/c types decorated with the DataContract attribute would satisfy any requirement for the type to be Serializable. But you'd likely be wrong. Yes, a type that is a [DataContract] is serializable in the literal sense, but it's serialized by the DataContractSerializer (see the References section at the end of this post for more details on WF Serialization)

So why is this an issue and what do you do about it? Often, non-trivial workflows span an amount of time that exceeds any given user's session. In fact, it's not uncommon for a non-trivial workflow to span as much as 30 days. Using a simple example, let's say that you are writing a Workflow to manage new employees. Further assume that there are several document requirements and that any deficiencies would result in severe penalties or liability risks. Just to make it clear, assume that each of the following must be procured before a new employee can start working. Further, assume that b/c of fees associated with each, if any previous one fails, that the whole process terminates (if someone's reference checks don't pass, there's no need to spend the money for a full background investigation as you know you're not going to hire them). [Also, this isn't a post on workplace hiring guidelines and is solely used for illustration - no need to point out why 'its bad business to drug test or whatever else].

Employment Application
Proof of Citizenship or ability to work in the U.S.
State withholding form
Federal withholding form
Reference check
License check
Completed Drug Screen
Full Background check

Implementation policies will vary from company to company but assume that all of these tasks wouldn't be completed within the user session that first created the entity. If you couldn't persist the workflow somehow and come back to it later, it would be of very little use. Workflow foundation provides an out-of-the-box solution named not surprisingly - Windows Workflow Persistence Service to help with long running workflows

Since Workflow Foundation is still in its infancy in terms of user adoption, many shops don't have well established design rules in place specifically for Workflow items. This can have some profound (although easily addressed in most cases) effects on Workflow development. It's common for a workflow to start out small in terms of steps and happen relatively quickly. When this is the case, there's little need for a persistence mechanism for the workflow. But as people get comfortable with WF and are willing to try more involved solutions, steps get added that often increase the time span the workflow could run to a point that's longer than the user session. For people new to WF, adding that first activity that'll possibly span a large amount of time is the first time they actually think seriously about the persistence service. And that's the point at which they often go back and try to retrofit things. In many cases, the number of "things" will be fairly substantial so it's quite easy to overlook something. Once you implement the persistence service, you'll typically go through the testing phase and make sure everything persist and can be retrieved correctly. And this is the time serialization problems with show themselves - often in a manner that's hard to isolate b/c the number of items involved.

In some cases, if there's a serialization problem, a fault will result. Unhandled faults in WF cause behavior that deviates from what you'd typically expect. So depending on your logging and tracing, you may or may not find the issue quickly. in many cases, you'll find the fault is related to serialization and you'll address it on the specific type, then go back and try to find every other type and make it serializable as well. This is likely to be overkill though - b/c you're likely to have some types that aren't involved in anything that's persisted and consequently don't require persistence. So you try to only make the items that will be persisted serializable. Until you get to the point where you're addressing everything in the planning and design stages, you're likely to run into situations like this and the only way out typically involves a lot of trial-and-error. That's why this post is relevant. If you go back and define each type that will be persisted as a [DataContract] , it'll take you some time to do, may necessitate you adding new references to some projects and ultimately, after all that's done, won't fix the problem. The following type may work all day long when just dealing with WCF's serialization requirements...

namespace Ger911.HCStandard.Core.Shared
{
    [DataContract]
    public class MatrixItem
    {
        [DataMember]
        public String EntityName { get; set; }
        [DataMember]
        public String ContactName { get; set; }
        [DataMember]
        public Int32 BedCount { get; set; }
        [DataMember]
        public String HospitalStatus { get; set; }
        [DataMember]
        public DateTime ModifiedDateTime { get; set; }
    }
}

But unless you modify it like this, you'll be in for some unpleasant surprises in WF:

namespace Ger911.HCStandard.Core.Shared
{

    [Serializable]
    [DataContract]
    public class MatrixItem
    {
        [DataMember]
        public String EntityName { get; set; }
        [DataMember]
        public String ContactName { get; set; }
        [DataMember]
        public Int32 BedCount { get; set; }
        [DataMember]
        public String HospitalStatus { get; set; }
        [DataMember]
        public DateTime ModifiedDateTime { get; set; }
    }
}

References:

Using Red Gate's Reflector, here's what you'll see under the hood of the WorkflowPesistenceService class's RestoreFromDefaultSerializedForm and GetDefaultSerializedForm. For further insight into this, use Reflector and examine the SqlWorkflowPersistenceService:

RestoreFromDefaultSerializedForm

protected static Activity RestoreFromDefaultSerializedForm(byte[] activityBytes, Activity outerActivity)
{
            Activity activity;
            DateTime now = DateTime.Now;
            MemoryStream stream = new MemoryStream(activityBytes);
            stream.Position = 0L;
            using (GZipStream stream2 = new GZipStream(stream, CompressionMode.Decompress, true))
            {
                activity = Activity.Load(stream2, outerActivity);
            }
            TimeSpan span = (TimeSpan)(DateTime.Now - now);
            WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "Deserialized a {0} to length {1}. Took {2}.",
                new object[] { activity, stream.Length, span }); return activity;
}

GetDefaultSerializedForm

protected static byte[] GetDefaultSerializedForm(Activity activity)
{
          DateTime now = DateTime.Now;
          using (MemoryStream stream = new MemoryStream(0x2800))
          {
              stream.Position = 0L;
              activity.Save(stream);
              using (MemoryStream stream2 = new MemoryStream((int)stream.Length))
              {
                  using (GZipStream stream3 = new GZipStream(stream2, CompressionMode.Compress, true))
                  {
                      stream3.Write(stream.GetBuffer(), 0, (int)stream.Length);
                  }
                  ActivityExecutionContextInfo info = (ActivityExecutionContextInfo)activity.GetValue(Activity.ActivityExecutionContextInfoProperty);
                  TimeSpan span = (TimeSpan)(DateTime.Now - now);
                  WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "Serialized a {0} with id {1} to length {2}. Took {3}.", new object[] { info, info.ContextGuid, stream2.Length, span });
                  byte[] array = stream2.GetBuffer();
                  Array.Resize<byte>(ref array, Convert.ToInt32(stream2.Length));
                  return array;
              }
          }
}

DataContractSerializer

public sealed class DataContractSerializer : XmlObjectSerializer
{
    // Fields
    private IDataContractSurrogate dataContractSurrogate;
    private bool ignoreExtensionDataObject;
    internal Dictionary<XmlQualifiedName, DataContract> knownDataContracts;
    private ReadOnlyCollection<Type> knownTypeCollection;
    internal IList<Type> knownTypeList;
    private int maxItemsInObjectGraph;
    private bool needsContractNsAtRoot;
    private bool preserveObjectReferences;
    private DataContract rootContract;
    private XmlDictionaryString rootName;
    private XmlDictionaryString rootNamespace;
    private Type rootType;

    // Methods
    public DataContractSerializer(Type type);
    public DataContractSerializer(Type type, IEnumerable<Type> knownTypes);
    public DataContractSerializer(Type type, string rootName, string rootNamespace);
    public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace);
    public DataContractSerializer(Type type, string rootName, string rootNamespace, IEnumerable<Type> knownTypes);
    public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace, IEnumerable<Type> knownTypes);
    public DataContractSerializer(Type type, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    public DataContractSerializer(Type type, string rootName, string rootNamespace, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    internal static DataContract GetDataContract(DataContract declaredTypeContract, Type declaredType, Type objectType);
    internal override Type GetDeserializeType();
    internal override Type GetSerializeType(object graph);
    internal static Type GetSurrogatedType(IDataContractSurrogate dataContractSurrogate, Type type);
    private void Initialize(Type type, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    private void Initialize(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    internal override bool InternalIsStartObject(XmlReaderDelegator reader);
    internal override object InternalReadObject(XmlReaderDelegator xmlReader, bool verifyObjectName);
    internal override void InternalWriteEndObject(XmlWriterDelegator writer);
    internal override void InternalWriteObject(XmlWriterDelegator writer, object graph);
    internal override void InternalWriteObjectContent(XmlWriterDelegator writer, object graph);
    internal override void InternalWriteStartObject(XmlWriterDelegator writer, object graph);
    public override bool IsStartObject(XmlDictionaryReader reader);
    public override bool IsStartObject(XmlReader reader);
    public override object ReadObject(XmlReader reader);
    public override object ReadObject(XmlDictionaryReader reader, bool verifyObjectName);
    public override object ReadObject(XmlReader reader, bool verifyObjectName);
    internal static object SurrogateToDataContractType(IDataContractSurrogate dataContractSurrogate, object oldObj, Type surrogatedDeclaredType, ref Type objType);
    public override void WriteEndObject(XmlDictionaryWriter writer);
    public override void WriteEndObject(XmlWriter writer);
    public override void WriteObject(XmlWriter writer, object graph);
    public override void WriteObjectContent(XmlDictionaryWriter writer, object graph);
    public override void WriteObjectContent(XmlWriter writer, object graph);
    public override void WriteStartObject(XmlDictionaryWriter writer, object graph);
    public override void WriteStartObject(XmlWriter writer, object graph);

    // Properties
    public IDataContractSurrogate DataContractSurrogate { get; }
    public bool IgnoreExtensionDataObject { get; }
    internal Dictionary<XmlQualifiedName, DataContract> KnownDataContracts { get; }
    public ReadOnlyCollection<Type> KnownTypes { get; }
    public int MaxItemsInObjectGraph { get; }
    public bool PreserveObjectReferences { get; }
    private DataContract RootContract { get; }
}

WCF to the rescue

William — Mon, 07 Jul 2008 05:00:00 GMT

Although part of the idea below was mine, James Ashley was crucial to helping me figure this out.

Problem:

Without getting into the ghoury details, we have an application that allows users to send messages to large groups of people. Anyone using a client application that is logged on will get a special notification which they can respond to once a message is sent. So far, Polling has been the bane of our existence. We're trying to fancy up the UI and Telerik's Winforms controls have helped out a lot, but there's simply no way I've been able to find to have a snappy UI with a lot of really cool looking effects - all the while polling every few seconds. Until now, I just bit down, and took a walk through multi-threadedville.

I wanted to remove the polling. We had experimented with a few different architectures, but all had the same problem, polling. So let's say you had 200 users logged on. In the User's bar, we wanted to show each user and their picture - much the same way IM does. This app had to work across network boundaries and you couldn't count on being able to use TCP so we had to at least make it work with http. If you poll every three seconds, to get the latest info on who's logged on and off, rebuilding the list of user's was painful. We resorted to several tricks to determine if a user was already in the list, but all of it was putting lipstick on a pig.

Solution:

One of the big things you often hear about with WCF is self-hosting. I had ignored it for the most part. But today, I wanted to basically have a Winforms app host one service, and a Windows Service host the other part of the service, having the services talk to each other. The client winforms app would simply talk to the client service, it would never hit the Windows Service directly.

So we built a client service and server service, with a client winforms app hosting the client service and a mock Windows Service (which was simply another winforms app) that hosted the service.

The problem we kept running into is as each client signed on to the system, how could we tell the server svc that they were online? Dynamically adding endpoints is child's play, but with each winforms app, you could only interact with the ServiceHost - not the service.

We tried using traditional events to no avail - that wasn't a surprise but we figured it's worth a try. Then James recommended a static event. I was completely skeptical, but alas it worked.

After looking at Juval's framework though, it became really clear. If we want the services to be able to interact with the hosts, then simply self-host the things.

So we had a method called ReceiveMessage which was called from the service (via a client proxy for the client service). Here's basically what the client looked like:

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

    ServiceHost currentHost = null;
    private void btnStartService_Click(object sender, EventArgs e)
    {
        currentHost = new ServiceHost(typeof(Form1));
        try
        {
            currentHost.Open();
            lblServiceStatus.Text = "Started";
        }
        catch (Exception ex)
        {
            lblServiceStatus.Text = ex.Message;
        }
    }

    public string ReceiveMessage(string msg)
    {
        String myMessage = msg;
        MessageBox.Show(myMessage);
        return msg;
    }

....

Now, from the Administrative application (which interacted with the service, you could Send a message by doing the following:)

private void btnSend_Click(object sender, EventArgs e)
{
      proxy = new ClientServiceClient(new NetNamedPipeBinding(), endpoint );
      try
      {
          proxy.ReceiveMessage(rtbMessageText.Text);
      }
      catch (FaultException ex)
      {
          lblServiceStatus.Text = ex.Message;
      }
}

ClientServiceClient is a stupid name for a client proxy class, but we were just experimenting - the main thing to note is that it's simply a proxy class for the client service, the same service that's effectively being hosted by the Winforms client. There's a server method called SendMessage(String msg) which you'd call on the service, which in turn would dynamically add endpoints for each active client , and then send the messages to them.

You can easily store all the information for clients you want to send messages to in a List<> or similar structure - or if you need stronger persistence or have different needs, then you can use a database. Either way the end result is the same - loop through all the clients, add an endpoint for each one, loop through each and call the method you want.

I'm having trouble getting to my ftp server from where i'm at, but I'll post the code when I can. In the meantime, if you're interested, just drop me a line.

Looking for some .NET Developers

William — Fri, 06 Jun 2008 05:00:00 GMT

A client of mine located in the Aiken/Columbia South Carolina Area has asked me if I had any friends who are .NET Developers and looking for a job. They are looking for at least one Junior Developer, on Mid-Level Developer and several Senior developers. I know these folks quite well and I can vouch for the following:

They pay extremely well
Generous benefits package
There's plenty of cool people on their staff
They are growing at an explosive rate so there's plenty of room for upward mobility. There's also a very strong focus on learning/teaching and career development.
They are an Agile/SCRUM shop
Currently developing with the following technologies:

Visual Studio Team System 2008 / .NET 3.5 Framework
Windows Communication Foundation
Windows Presentation Foundation
ASP.NET
LINQ
Silverlight
Windows Mobile 5/ Windows Mobile 6/ .NET Compact Framework
Sql Server 2005 / Sql Server 2008
Windows Installer for XML
Sandcastle

If you're in the area and looking for a job... if you know someone who looking for a job.... or if you're willing to move, please drop me a line using the Contact option on my blog or emailing me directly at WilliamRyan@gmail.com and I'll put you in contact with them. They are looking to hire folks immediately so I can probably get you an interview within a few days.

Junior Developer:

Ideal candidate will be a recent college graduate with a Computer Science of MIS degree. No experience is necessary for this position. The main soft-skill qualifications for this position are:

A true love for development
Strong desire to learn
A desire to stand out among one's peers

The hard-skill qualifications include a good theoretical understanding of at least two of the following:

Object Oriented Design and Analysis
Relational Database theory
Design Patterns
Familiarity with at least two of the following: C, C++, Java, C#, VB.NET

This is essentially a dream job for recent college grads b/c the job is being offered "no experience required". Since they are a SCRUM/Agile shop, you'll get to work extensively with their Senior and Mid level devs via Pair Programming. You'll be able to pick an area to specialize in which you will decide on for yourself. Additionally, you'll be using some of the most sought after Microsoft technologies available. Go to Monster.com or Dice.com and see for yourself how much demand there is for the above technologies and how much those jobs pay. You'll get to work with these on day 1 and essentially carve out a path for yourself using whichever technologies you like the best. If you want to be a "UI" expert, that's where you'll be put. If you want to be a Web Services dev, again, that's what you can focus on. If you want to be an expert buildmaster who specializes in installers, that's what you'll get to do. The company is looking for some excellent candidates and willing to offer a really fun and great paying job with plenty of training and career development available.

Mid-Level Developer:

The ideal candidate will have a computer science or MIS degree and 1-3 years of development experience. The ideal candidate will have two or more the following abilities:

Solid command of OOP/OOD using C++, C#, Java or VB.NET
Test Driven Design
Service Oriented Architecture
Familiarity with MySql, Sql Server (T-SQL), Oracle (PL/SQL)
Basic understanding of both Winforms and ASP.NET
Basic familiarity with Web Services, MSMQ, Enterprise Services/COM+, .NET Remoting, DCOM, J2EE, Java Beans

Just like the Junior development positions, these ones will provide a great deal of flexibility to learn and specialize the area of your choice. These are considered 'fast track' positions to move into the Senior Developer or Architect roles

Senior Developer:

The ideal candidate will be someone with at least 4 years experience. This person will love challenges and love coming up with solutions to problems that other people run from. They will be people that love figuring out how to do things that everyone else said can't be done. They will be the stereotypical Alpha-Geek, Someone that spends their spare time answering quiz questions like these:

All of the requirements for the Mid-Level Developer as well as several of the following skills:

Proficiency with T-Sql or PL/SQL. You should be able to write a 5 table join on your own. You should have written several stored procedures that were > 100 lines long.
Strong command of query tuning and ability to easily spot design flaws
Ability to design 'real' objects.

Someone who pays meticulous attention to the scope modifiers of their classes/functions/properties
Someone who understands the problems associated with coupling and strives to avoid it.
Someone who can write and use events in their classes without thinking twice about it.
Someone with a solid understanding of thread safety and thread synchronization
Someone who is comfortable using several different design patterns
Someone who is comfortable implementing several different interfaces in one object, using combinations of interface implementation and inheritance and someone who can use inheritance responsibly

Keeps up with technology, reads computer books regularly, has favorite blogs in multiple disciplines and/or blogs themselves, attends or speaks at user's groups, is active in one or more online forum or newsgroup
Someone who answers "Which is better, C# or VB.NET?" with "Either can be better depending on the circumstances but I'm comfortable writing in either of them" and then "But I've been learning F# lately and it's really been growing on me"
Experience with .NET Remoting, Web Services & Web Services Enhancements, MSMQ, Enterprise Services and/or WCF
Ability to create syntactically correct UML diagrams (meaning they can do more than write the letters "UML" on their resume) and if not, they are willing to learn to do this.
Understands data structures solidly and could easily implement their own HashTable or LinkedList
Someone who's always looking to come up with a newer, cooler, faster, and more secure way to do implement something
Experienced with either Biztalk server or Sharepoint
Takes pride in their code without falling in love with it or getting all defensive about it. Ability to acknowledge the fact that everyone makes mistakes and can talk about their mistakes/bugs without getting defensive.
Someone who is the first to raise their hand whenever the boss says "I need someone to learn ____________, do I have any volunteers"

Basically, if you love development, love creating new cutting edge solutions all the while making a lot of money and having a lot of fun you definitely should talk to these folks. If you're interested...... Please drop me a line using the Contact option on my blog or emailing me directly at WilliamRyan@gmail.com and I'll put you in contact with them.

Cool Powershell script

William — Tue, 20 May 2008 05:00:00 GMT

I can't take credit for this, I came across it in Windows Communication Foundation Unleashed - but it's very helpful for administering Windows Communication Foundation...

In the <diagnostics> tag of your service's configuration, two available options are wmiProviderEnabled and performanceCounters. So ideally you'll want to set both, but if you just need to identify the endpoint then only the first one is necessary:

<system.serviceModel>

<diagnostics

wmiProviderEnabled="true"

performanceCounters="ServiceOnly"/>

</system.ServiceModel>

After you have that in place for your service(s), you can use the following Powershell script

PS C:\Windows\System32> get-wmiobject endpoint -n root\ServiceModel | ft name

I don't know if I love Powershell more than Windows Communication Foundation or WCF more than Powershell, but few things are cooler than using them together and this is one script you'll undoubtedly find helpful.

ChannelFactory.CreateChannel goes to the Gentlemen's Club

William — Mon, 12 May 2008 05:00:00 GMT

Currently, I'm tasked with getting some people up to speed on .NET 3.5 as well as WCF. WCF is really cool and it's easy to fall in love with, but it's also easy to cause you to sleep when you're first learning it. So instead of walking through Hello World, I changed course.

Basically, we're using an architecture where the Business Layer and Data Layer are services. In most cases, we'd run them on the same machine, in Proc. In other cases, when scalability is more of an issue, we'd need to separate them out.

Creating Services is nothing special and other than a few attributes (ServiceContract, OperationContract, often DataContract and/or DataMember or EnumMember) and an interface, there's no real way to tell a wcf service from any other class (and since most of those attributes should go on the interface, the class itself shows no sign of being a service other than the interface implementation). One thing though, when you add a WCF service to an application through VS, it will stick the service class and the corresponding interface into the same project. I typically move my interfaces out of the project and into a library so that I can share them. In a case where your business methods just call the dal's methods, the interfaces/contracts will be the same so you may be able to share them.

WCF gives you similar hosting options to Remoting and Web Services. You can add a Service Reference and have svcutil.exe generate a proxy class which is virtually identical to what you did with web services. Hosting them is the easy part and if you can run a Console application and remember to put Console.Readline at the end of it, you can start a service host. There's about a zillion examples out there and it's usually one of the first things covered in WCF so I'm leaving that alone for now.

On the client, you can add a service reference as I said. However that is not without its problems and you may want a little more flexibility. If you want to create your own proxies, there are two primary methods (outside of svcutil related approaches). Let's say you have the following interface:

namespace Cuckooz.Sample.WCFStripClub { [DataContract] public enum BounceLevel{

[EnumMember] Lame, [EnumMember] Woot, [EnumMember] YeahBaby };

[DataContract] public enum PoleManeuver{ [EnumMember] Standard, [EnumMember] LookMaNoHands, [EnumMember] UpsideDownLookMaNoHands }; [ServiceContract] public interface IStripper { [OperationContract] String Bounce(BounceLevel bouncin); [OperationContract] String SlideDownPoll(PoleManeuver maneuver); [OperationContract] long MilkSuckerForCash(String customerName); } }

One approach is to create your own Proxy class , inheriting from ClientBase and passing in the type of the interface, while implementing the interface. Pay attention to the implementations of this class:

namespace Cuckooz.Sample.WCFStripClub { public partial class PurePlatinumServiceClient : ClientBase<IStripper>, IStripper {

public PurePlatinumServiceClient() { }

public PurePlatinumServiceClient(String endpointConfigurationName) : base(endpointConfigurationName) { }

public PurePlatinumServiceClient(String endpointConfigurationName, String remoteAddress) : base(endpointConfigurationName, remoteAddress) { }


        public PurePlatinumServiceClient(Binding binding, EndpointAddress remoteAddress) : base(binding, remoteAddress) { }
        public String Bounce(BounceLevel bouncin)
        {
            return base.Channel.Bounce(bouncin);
        }
        public String SlideDownPoll(PoleManeuver maneuver)
        {
            return base.Channel.SlideDownPoll(maneuver);
        }

public long MilkSuckerForCash(String customerName) { return base.Channel.SlideDownPoll(customerName); } } }

Note that b/c we are passing in the interface as a generic type parameter to ClientBase, we can refer to it through base.Channel.MethodName.

You will need to have an endpoint configured in order to call the service and you should give the endpoint a name to make things easy. In this case, I have a namedPipe endpoint configured named "NamedPipe". With that in place, you simply need to create an instance of your proxy and have at it:

PurePlatinumServiceClient dancerProxy = new PurePlatinumServiceClient("NamedPipe"); Console.WriteLine(dancerProxy.Bounce(BounceLevel.YeahBaby)); Console.WriteLine(dancerProxy.SlideDownPoll(PoleManeuver.UpsideDownLookMaNoHands)); Console.WriteLine(dancerProxy.MilkSuckerForCash("Peter Griffin"));

If you are going to create your proxies like this, do yourself a favor and use CodeSmith, some other template, or if you're just really hard up, copy and paste where applicable - it'll save you a lot of time.

If you don't want to go this route though, you can skip the whole proxy altogether. Using the ChannelFactory class, you can specify the same interface we used above and create a new ChannelFactory. Remember to name your endpoints in the configuration file so that you can refer to them. Otherwise, you'll need to specify the endpoint hard code style - which is lame. Once you've done that, you instantiate an IYourInterface object using the CreateChannel method of the ChannelFactory you just created. Then, you should cast it to an IDisposable object and throw it in a using block, and have at it from there. Note, you don't have to use IDispose but the other approach is to cast it as a ICommuncationObject and then call Close. For the money, it's easier and safer to just go the IDispose route. So the code below is functionally equivalent to the preceding block:

ChannelFactory<IStripper> stripperFactory = new ChannelFactory<IStripper>("NamedPipe"); IStripper serviceInstance = stripperFactory.CreateChannel(); using (serviceInstance as IDisposable) { Console.WriteLine(serviceInstance.Bounce(BounceLevel.Woot)); Console.WriteLine(serviceInstance.SlideDownPoll(PoleManeuver.LookMaNoHands)); Console.WriteLine(serviceInstance.MilkSuckerForCash("Peter Griffin")); }

Either of these approaches provides a ton of flexibility. For instance, you can create several endpoints, look at the environment and then decide which endpoint you want to talk on, hence, which binding you are going to use. Similarly, if you had several services you could easily change the execution to use on over the other ones. All in all it really couldn't be simpler and in this case, the hardest part of the equation is going to be setting up your configuration file properly.

If I have time tomorrow I'll post the next lesson which uses Duplexing, there's a lot of potential with this interface and service when you enhance it with duplexing ;-)

Silverlight for Windows Mobile

William — Mon, 17 Mar 2008 05:00:00 GMT

Speaking of new features that should help Windows Mobile remain the dominant player in the market, a mobile version of Silverlight is going to be coming down the highway .

The good news:

Expected release is Q2 - 2008
You can use Expression Blend to develop it with. So you won't need a new or additional IDE

The bad news:

It will be Silverlight 1.0

I know, the teeth on that horse you gave me are a little crooked. Response time is really going to be the big factor here... if it's fast and works right, this is going to be a huge, HUGE, feature that will open many doors to mobile development.

Dabbling in LINQ to ADO.NET

William — Sat, 05 Jan 2008 06:00:00 GMT

I'll be doing a training seminar in Stockholm next month and I've been trying to create some compelling examples to illustrate various concepts. Although it's keeping me busy, there's a lot I've been working on that's blogworthy.

One concept in LINQ to SQL that's I am pretty fond of is the use of Entities. There's so much you can do with Entities that it would take quite a few posts to do them justice, but I'll show a simple example of how they can be used. Assuming we're using SQL Server 2005 for this example, I have a database table with the following table definition:

GO /****** Object: Table [dbo].[Bank] Script Date: 01/05/2008 21:14:48 ******/ SET ANSI_NULLS ON GO SET QUOTED_IDENTIFIER ONGO SET ANSI_PADDING ON GO CREATE TABLE [dbo].[Bank]( [BankID] [int] IDENTITY(1,1) NOT NULL, [Name] [varchar](150) COLLATE SQL_Latin1_General_CP1_CI_AS NULL, [URL] [varchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NULL, [bigLogo] [varchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NULL, [smallogo] [varchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NULL, CONSTRAINT [PK_Bank] PRIMARY KEY CLUSTERED ( [BankID] ASC ) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF ,ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON)

ON [PRIMARY] ) ON [PRIMARY] GO SET ANSI_PADDING OFF

So the first thing we need to do is create a class with the same definition (note, if you are using a member name that's the same as the column name in the db, no additional steps need taken. If you use different names, then you need to specify a Name value . Field names are not case sensitive [meaning as long as they have the same spelling as the field in the db, the capitalization can be different]). So you use [Column(Name="DBColumnName")] public Type AliasNameYouWantToUse

using System.Linq;
using System.Linq.Expressions; 
using System.Data.Linq.Mapping;
namespace Ryan.Samples.Linq.ADONET {
     [Table(Name="Bank")] 
     public class Bank { 
     [Column]
     public Int32 BankID;
     [Column]
     public String Name; 
     [Column] 
     public String URL;
     [Column] 
     public String biglogo;
     [Column]
     public String smallogo;
    }
}

Now, we have a Bank class which corresponds to the Bank table in the database. For this sample, I created a static class with a static property named Globals and ConnectionString respectively. Now, I compose a quick LINQ query to retrieve all of the data in the table except records where the Bank's Name is PNC:

static void Main(string[] args)
{
   DataContext db = new DataContext(Globals.ConnectionString);
   Table <Banks> = db.GetTable<Bank>();

     var query =
           from b in Banks
           where b.Name != "PNC"
     select new { b.BankID, b.Name, b.URL };

     foreach (var row in query)
     {
         Console.WriteLine(row);
     }
     Console.ReadLine();
}

The syntax is pretty straightforward on the LINQ side so it doesn't really need explaining - if you can't tell what it's doing though, it's selecting each value that doesn' t have 'PNC' as a name. The Select statement is using a new C# language feature known as Anonymous types meaning that, a new type is being created without a traditional definition - that's why the new keyword is used.

When I first learned LINQ though, I wondered how this worked. Was the whole table retrieved from the database and then records restricted via LINQ? If so, this would seem very wasteful b/c by virtue of the restriction, you know you're only using a subset of the total values so why pull down everything? Fortunately that's not what happens. GetTable doesn't acttually pull down everything from the table - it's merely an instruction about how to generate the query it will use. As you probably have noticed, nowhere in here have we defined anything reminiscent of the CommandText property you'd use with a IDBCommand object. To prove that you aren't pulling down a whole table as you might with the old TableDirect instruction, run profiler before this code block executes. The results will show the following (assuming you are logging the same values).

Here's the resulting output:

exec sp_executesql N'SELECT [t0].[BankID], [t0].[Name], [t0].[URL]
FROM [Bank] AS [t0]
WHERE [t0].[Name] <> @p0',N'@p0 nvarchar(3)',@p0=N'PNC'

And just for the record, nothing before this ran a query on this table let alone one without a restriction. The output for running this code is shown below:

{ BankID = 1, Name = Bank of America, URL = www.bankofamerica.com }

{ BankID = 2, Name = Citi Bank, URL = www.citibank.com }

{ BankID = 3, Name = 1st Tennessee, URL = http://www.firsttennessee.com/ }

{ BankID = 4, Name = Citi Group, URL = www.citigroup.com }

{ BankID = 5, Name = JP Morgan, URL = www.jpmorgan.com }

{ BankID = 7, Name = UMB, URL = www.umb.com }

{ BankID = 8, Name = US Bank, URL = www.usbank.co }

{ BankID = 9, Name = BMO Financial Group, URL = www4.bmo.com/ }

{ BankID = 10, Name = M & T, URL = http://www.mandtbank.com/ }

{ BankID = 11, Name = National City, URL = http://www.nationalcity.com }

This brings up one other point... I could have changed the Console.WriteLine to just write out one or more of the properties of 'row'. In general, I make a rule of *always* overriding the ToString() method in any object I create just so that I can use it for meaningful information. With LINQ in particular, this becomes particularly useful b/c had I not used an anonymous type, (so the last line would read 'select b;' instead of 'select new {b.BankID, b.Name, b.URL}; I would have had the following useless output:

Ryan.Samples.Linq.ADONET.Bank

I could get around that by formatting the output in the Console.WriteLine method but that's might inelegant. Instead, by overriding the ToString() method, I can get the following output instead:

<I''ve truncated several records just for the sake of readability>

BankID - 1

Name - Bank of America

URL - www.bankofamerica.com

biglogo - baclogo.jpg

smallogo - bigbanksmall.jpg

BankID - 2

Name - Citi Bank

URL - www.citibank.com

biglogo - citibanklogo.jpg

smallogo - bigbanksmall.jpg

BankID - 3

Name - 1st Tennessee

URL - http://www.firsttennessee.com/

biglogo - 1sttennlogo.jpg

smallogo - 1sttennsmall.jpg

Needless to say, this is a lot more useful than simply knowing the fully qualified object name.