VS.Net and development

The new Visual Studio is here, the new Visual Studio is here...

Steve Loethen — Tue, 20 Nov 2007 03:59:52 GMT

For those of you living under a rock, let me clue you in. This morning, VS 2008, formally called Orcas, was released to the MSDN subscription download service. If you have a subscription, run, do not walk, to get it.

It was a bit of a struggle this morning. The servers were getting hammered pretty hard, but I finally got in. Okay, you say, Steve, you work for Microsoft, couldn't you just call up Bill and ask for a copy? Trust me, the MSDN server's got the bits before the internal download sites did. And MSDN downloads quicker. :)

Pulled it down, burned a dvd, and installed it on my freshly built Vista 64 bit box. Tomorrow, the fun begins.

Technorati Tags: codetolive

Get your game on....

Steve Loethen — Tue, 30 Oct 2007 14:00:55 GMT

Dream of writing the next Halo? Want to retire to a tropical island on the revenue from selling your independent game company? Or do you want to write and share your vision of gaming with the world? Then check this out:

http://www.imgdc.com

What is IMGDC?

The Indie MMO Game Developers Conference was an incredible success last year, full of passionate designers and developers. The excitement and pure dedication to the art of building virtual worlds was apparent and astounding. A strong focus on networking at IMGDC allows Indie developers to gain a massive amount of invaluable connections and information relevant to the size of project they are working on. Eric Rhea stated last year that IMGDC allowed for over $30,000 in free consultations with industry professionals.

IMGDC is a venue for Independent designers and developers to come together to share ideas and learn in all areas related to MMOGs. IMGDC 2.0 has positioned itself to be an even larger venue with three fantastic tracks covering design, development and business aspects of Indie MMOGs. The present is a time of MMOG giants, but the future lies in the hands of the passionate Indie developers. Do you have the passion?

Where/When is IMGDC?

Minneapolis Convention Center, March 29th & 30th, 2008.

Hope to see you there...

Technorati Tags: codetolive , xbox , games

CodeToLive Podcast from the Heartland Developers Conference...

Steve Loethen — Mon, 22 Oct 2007 10:59:16 GMT

Last week I journeyed to the sunny (okay, soggy) environs of Omaha Nebraska to attend and present at the Heartland Developers Conference. Along with my sparkling personality, I took the CodeToLive Harley and a good presentation on an introduction to WF. Some in my session asked for a link to the Hands on Labs for WF and Orcas.

WorkFlow Hands on labs...

Enjoy. Takes a couple of hours.

While there, we conducted a few podcast recording, and I was interviewed on one of them. Go have a listen and see what you think. It might give you some insight into what codetolive is and what we are trying to achieve.

http://geekswithblogs.net/jjulian/archive/2007/10/18/116138.aspx

Technorati Tags: codetolive, HDC, WF

New MSDN tester resource...

Steve Loethen — Mon, 22 Oct 2007 09:58:10 GMT

A new resource for those lonely testers. Announced this morning.

http://msdn2.microsoft.com/en-us/testing/default.aspx

Go take a look as see if it has value. Let me know what you think. If any of my tester friends out there want to take a look and do a video interview about what your thoughts are, let me know. I would be happy to help get the interview done, and get it published on the CodeToLive show on Channel 9.

Technorati Tags: .net, testing, codetolive

More XNA demo's on CodeToLive...

Steve Loethen — Wed, 03 Oct 2007 07:42:54 GMT

2 more episodes of Jennifer M's XNA toolkit series went live on the Code To Live show on channel 9 late yesterday. Already getting a lot of views. Go forth and enjoy.

Technorati Tags: Codetolive

With all these messages flying about, what do they look like...

Steve Loethen — Tue, 26 Jun 2007 18:16:45 GMT

So far we have a contract, 2 client/server pairs (one programmatic and one administrative). We can observe that the highly difficult tasks of text concatenation and changing case are happening. But these examples are extremely trivial, and as we increase complexity, try new things, it would be nice to observer what is going on, especially when it does not go well.

Luck for us, there is a built in logging facility in .NET and a complete feature set and viewing tool specifically for WCF. And all can be accomplished via the config file. Let's hit the servers config file.

First, lets set up diagnostics...

<system.diagnostics>
  <sources>
    <source name="System.ServiceModel"
            switchValue="Information, ActivityTracing"
            propagateActivity="true" >
      <listeners>
        <add name="xml"/>
      </listeners>
    </source>
    <source name="System.ServiceModel.MessageLogging">
      <listeners>
        <add name="xml"/>
      </listeners>
    </source>
    <source name="myUserTraceSource"
            switchValue="Information, ActivityTracing">
      <listeners>
        <add name="xml"/>
      </listeners>
    </source>
  </sources>
  <sharedListeners>
    <add name="xml"
         type="System.Diagnostics.XmlWriterTraceListener"
               initializeData="d:\logs\Traces.svclog" />
  </sharedListeners>
 </system.diagnostics>

This is straight out of the WCF help file. It defines 3 sources, that use a common trace log, located at d:\logs\traces.svclog. The first 2 come from system components, the third from a source I can drive. We are not currently driving it yet, but let's leave it in so we can put stuff in it later for debugging purposes.

So, the trace destination is there. Let's tell the WCF system to feed it.

The above big of config fell into the <configuration> section of our app.config. The next bit is inside our System.ServiceModel section.

    <diagnostics wmiProviderEnabled="true">
      <messageLogging 
           logEntireMessage="true" 
           logMalformedMessages="true"
           logMessagesAtServiceLevel="true" 
           logMessagesAtTransportLevel="true"
           maxMessagesToLog="3000" 
       />
    </diagnostics>

As you can see, we have enabled several things here. This produces a lot of good info about what is going on. We see the entire message, both good and bad, at both the service and transport level. You can trim this down. As we run the service, it puts our tracing in our log file. We could just open this file via Notepad, and brute force our way to knowledge, but guess what. There is a better way. svcTraceView.exe is part of the windows sdk. This gives us nice formatted output.

<MessageLogTraceRecord>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
<s:Header>
<Action s:mustUnderstand="1" xmlns="http://schemas.microsoft.com/ws/2005/05/addressing/none">MyService/IMyContractInterface/SayHelloResponse</Action>
</s:Header>
<s:Body>
<SayHelloResponse xmlns="MyService">
<SayHelloResult>hello bob</SayHelloResult>
</SayHelloResponse>
</s:Body>
</s:Envelope>
</MessageLogTraceRecord>

This is the message response from our "SayHello" method, which was given "bob" to append to the word "Hello ". Not bad.

Technorati Tags: WCF, visual studio, dot net

We will come back to this took and logging periodically to view the effects of binding and hosting changes...

For now....

Let's add config file support to the client...

Steve Loethen — Fri, 22 Jun 2007 12:16:50 GMT

We have overhauled the server to support the endpoints in the config file. Let's do the same for the Client. We can then start playing with various config file settings.

Just to preserve the samples, I am going to copy the client code to a new app, and modify the new one. Let's call it WCFConsoleClientCfg.

Step 1. Delete the interface file we had in the previous client. We are going to use a tool to recreate it. Or at least it's equivalent.

Step 2. go to project->add new and pick a application configuration file.

Step 3. Fire up our Server. One thing we need to do is make sure the server is configured to provide metadata via httpget. This can be done in code, but since we are serving up with a app.cofig on the server side as well, all we have to do is add to our behavior. Our new app.config for the server looks like this.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service behaviorConfiguration="MyService" name="WCFContract.myContractImplementation">
        <endpoint address="ConsoleService" binding="basicHttpBinding" name="ConsoleService" contract="WCFContract.IMyContractInterface"/>
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:8001/WCFConsoleHostedService"/>
          </baseAddresses>
        </host>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="MyService">
          <serviceMetadata httpGetEnabled="true"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

You see that we have added a behavior to our "MyService" behavior. This enables http get access to the metadata about our service. Hence the name httpGetEnabled="true". That will allow a utility to get the info.

Step 4. Use IE to browse to our service by hitting http://localhost:8001/WCFConsoleHostedService". When you do that you get back a web page that talks about the available endpoints, how to get to a generated proxy class and app.config file. And you get a sample use of the proxy in both vb and c#. The magic words are :

svcutil.exe http://localhost:8001/WCFConsoleHostedService?wsdl

you can also specify where you want the files generated, and under what name. Plus some other stuff. Lots of options. Here is the output of svcutil /?

(Short Form: /?)

-= CODE GENERATION =-

Description: svcutil.exe can generate code for service contracts, clients and
    data types from metadata documents. These metadata documents can be on disk
    or retrieved online. Online retrieval follows either the WS-Metadata
    Exchange protocol or the DISCO protocol.

Syntax: svcutil.exe [/t:code] <metadataDocumentPath>* | <url>* | <epr>

<metadataDocumentPath> - The path to a metadata document (wsdl or xsd).
                          Standard command-line wildcards can be used in the
                          file path.
<url>                  - The URL to a service endpoint that provides metadata
                          or to a metadata document hosted online. For more
                          information on how these documents are retrieved see
                          the Metadata Download section.
<epr>                  - The path to an XML file that contains a WS-Addressing
                          EndpointReference for a service endpoint that supports
                          WS-Metadata Exchange. For more information see the
                          Metadata Download section.

Options:

/out:<file>                        - The filename for the generated code.
                                      Default: derived from the WSDL definition
                                      name, WSDL service name or targetNamespace
                                      of one of the schemas. (Short Form: /o)
/config:<configFile>               - The filename for the generated config
                                      file. Default: output.config
/mergeConfig                       - Merge the generated config into an
                                      existing file instead of overwriting the
                                      existing file.
/noConfig                          - Do not generate config
/dataContractOnly                  - Generate code for Data Contract types
                                      only. Service Contract types will not be
                                      generated. (Short Form: /dconly)

/language:<language>               - The programming language to use for
                                      generating code. Provide either a language
                                      name registered in the machine.config file
                                      or provide the fully-qualified name of a
                                      class that inherits from
                                      System.CodeDom.Compiler.CodeDomProvider.
                                      Examples of language names to use are CS
                                      and VB. Default: C#. (Short Form: /l)
/namespace:<string,string>         - A mapping from a WSDL or XML Schema
                                      targetNamespace to a CLR namespace. Using
                                      the '*' for the targetNamespace maps all
                                      targetNamespaces without an explicit
                                      mapping to that CLR namespace. Default:
                                      derived from the target namespace of the
                                      schema document for Data Contracts. The
                                      default namespace is used for all other
                                      generated types. (Short Form: /n)

/messageContract                   - Generate Message Contract types. (Short
                                      Form: /mc)
/enableDataBinding                 - Implement the System.ComponentModel.INotif

                                      yPropertyChanged interface on all Data
                                      Contract types to enable data binding.
                                      (Short Form: /edb)
/serializable                      - Generate classes marked with the
                                      Serializable Attribute. (Short Form: /s)
/async                             - Generate both synchronous and asynchronous
                                      method signatures. Default: generate only
                                      synchronous method signatures. (Short
                                      Form: /a)
/internal                          - Generate classes that are marked as
                                      internal. Default: generate public
                                      classes. (Short Form: /i)

/reference:<file path>             - Reference types in the specified assembly.
                                      When generating clients, use this option
                                      to specify assemblies that might contain
                                      types representing the metadata being
                                      imported. (Short Form: /r)
/collectionType:<type>             - A fully-qualified or assembly-qualified
                                      name of the type to use as a collection
                                      data type when code is generated from
                                      schemas. (Short Form: /ct)
/excludeType:<type>                - A fully-qualified or assembly-qualified
                                      type name to exclude from referenced
                                      contract types. (Short Form: /et)
/noStdLib                          - Do not reference standard libraries. By
                                      default mscorlib.dll and
                                      system.servicemodel.dll are referenced.

/serializer:Auto                   - Automatically select the serializer. This
                                      tries to use the Data Contract serializer
                                      and uses the XmlSerializer if that fails.
                                      (Short Form: /ser)
/serializer:DataContractSerializer - Generate data types that use the Data
                                      Contract Serializer for serialization and
                                      deserialization
/serializer:XmlSerializer          - Generate data types that use the
                                      XmlSerializer for serialization and
                                      deserialization
/importXmlTypes                    - Configure the Data Contract serializer to
                                      import non-Data Contract types as
                                      IXmlSerializable types.

-= METADATA EXPORT =-

Description: svcutil.exe can export metadata for services, contracts and data
    types in compiled assemblies. To export metadata for a service, you must use
    the /serviceName option to indicate the service you would like to export. To
    export all Data Contract types within an assembly use the /dataContractOnly
    option. By default metadata is exported for all Service Contracts in the
    input assemblies.

Syntax: svcutil.exe [/t:metadata] [/serviceName:<serviceConfigName>]
[/dataContractOnly] <assemblyPath>*

<assemblyPath> - The path to an assembly that contains services, contracts or
Data Contract types to be exported. Standard command-line
wildcards can be used to provide multiple files as input.

Options:

/serviceName:<serviceConfigName> - The config name of a service to export. If
                                    this option is used, an executable assembly
                                    with an associated config file must be
                                    passed as input. Svcutil will search through
                                    all associated config files for the service
                                    configuration. If the config files contain
                                    any extension types, the assemblies
                                    containing these types must either be in the
                                    GAC or explicitly provided using the /r
                                    option.
/reference:<file path>           - Add the specified assembly to the set of
                                    assemblies used for resolving type
                                    references. If you are exporting or
                                    validating a service that uses 3rd-party
                                    extensions (Behaviors, Bindings and
                                    BindingElements) registered in config use
                                    this option to locate extension assemblies
                                    that are not in the GAC. (Short Form: /r)
/dataContractOnly                - Operate on Data Contract types only. Service
                                    Contracts will not be processed. (Short
                                    Form: /dconly)
/excludeType:<type>              - The fully-qualified or assembly-qualified
                                    name of a type to exclude from export. This
                                    option can be used when exporting metadata
                                    for a service or a set of service contracts
                                    to exclude types from being exported. This
                                    option cannot be used with the /dconly
                                    option. (Short Form: /et)

-= SERVICE VALIDATION =-

Description: Validation is useful to detect errors in service implementations
without hosting the service. You must use the /serviceName option to
indicate the service you would like to validate.

Syntax: svcutil.exe /validate /serviceName:<serviceConfigName> <assemblyPath>*

<assemblyPath> - The path to an assembly containing service types to be
                  validated. The assembly must have an associated config file to
                  provide service configuration. Standard command-line wildcards
                  can be used to provide multiple assemblies.

Options:

/validate                        - Validate a service implementation. To
                                    validate a service, you must use the
                                    /serviceName option to indicate the service
                                    you would like to validate. If this option
                                    is used, an executable assembly with an
                                    associated config file must be passed as
                                    input. (Short Form: /v)
/serviceName:<serviceConfigName> - The config name of a service to validate. To
                                    validate a service this option must be
                                    provided. Svcutil will search through the
                                    associated config files of all input
                                    assemblies for the service configuration. If
                                    the associated configuration file contain
                                    any extension types, the assemblies
                                    containing these types must either be in the
                                    GAC or explicitly provided using the /r
                                    option.
/reference:<file path>           - Add the specified assembly to the set of
                                    assemblies used for resolving type
                                    references. If you are exporting or
                                    validating a service that uses 3rd-party
                                    extensions (Behaviors, Bindings and
                                    BindingElements) registered in config use
                                    this option to locate extension assemblies
                                    that are not in the GAC. (Short Form: /r)
/dataContractOnly                - Operate on Data Contract types only. Service
                                    Contracts will not be processed. (Short
                                    Form: /dconly)
/excludeType:<type>              - The fully-qualified or assembly-qualified
                                    name of a service type to exclude from
                                    validation. (Short Form: /et)

-= METADATA DOWNLOAD =-

Description: svcutil.exe can be used to download metadata from running services
    and save the metadata to local files. To download metadata, you must
    explicitly specify the /t:metadata option. Otherwise, client code will be
    generated. For http and https URL schemes svcutil.exe will try to retrieve
    metadata using WS-Metadata Exchange and DISCO. For all other URL schemes
    svcutil.exe will only try WS-Metadata Exchange. By default, svcutil.exe uses
    the bindings defined in the
    System.ServiceModel.Description.MetadataExchangeBindings class. To configure
    the binding used for WS-Metadata Exchange you must define a client endpoint
    in config that uses the IMetadataExchange contract. This can be defined
    either in svcutil.exe's config file or in another config file specified
    using the /svcutilConfig option.

Syntax: svcutil.exe /t:metadata <url>* | <epr>

<url> - The URL to a service endpoint that provides metadata or an URL that
points to a metadata document hosted online.
<epr> - The path to an XML file that contains a WS-Addressing EndpointReference
for a service endpoint that supports WS-Metadata Exchange.

-= XMLSERIALIZER TYPE GENERATION =-

Description: svcutil.exe can pre-generate C# serialization code that is required
    for types that can be serialized using the XmlSerializer. svcutil.exe will
    only generate code for types used by Service Contracts found in the input
    assemblies.

Syntax: svcutil.exe /t:xmlSerializer <assemblyPath>*

<assemblyPath> - The path to an assembly containing Service Contract types.
Serialization types will be generated for all Xml Serializable
types in each contract

Options:

/reference:<file path> - Add the specified assembly to the set of assemblies
                          used for resolving type references. (Short Form: /r)
/excludeType:<type>    - Fully-qualified or assembly-qualified type name to
                          exclude from export or validation. This option can be
                          used when exporting metadata for a service or a set of
                          service contracts to exclude types from being
                          exported. This option cannot be used with the
                          /dataContractOnly option. (Short Form: /et)
/out:<file>            - Filename for the generated code. This option will be
                          ignored when multiple assemblies are passed as input
                          to the tool. Default: derived from the assembly name.
                          (Short Form: /o)

-= EXAMPLES =-

svcutil http://service/metadataEndpoint
- Generate client code from a running service or online metadata documents.

svcutil /dconly http://service/metadataEndpoint
- Generate Data Contract types from a running service or online metadata
documents.

svcutil *.wsdl *.xsd /language:C#
- Generate client code from local metadata documents.

svcutil /dconly *.xsd /language:VB
- Generate Data Contract types in VisualBasic from local schema documents.

svcutil /t:metadata http://service/metadataEndpoint
- Download metadata documents from running services

svcutil myAssembly.dll
- Generate metadata documents for Service Contracts and associated types in
an assembly

svcutil myServiceHost.exe /serviceName:myServiceName
- Generate metadata documents for a service, and all associated Service
Contracts and data types in an assembly

svcutil myServiceHost.exe /dconly
- Generate metadata documents for data types in an assembly

svcutil /validate /serviceName:myServiceName myServiceHost.exe
- Verify service hosting

svcutil /t:xmlserializer myContractLibrary.exe
- Generate serialization types for XmlSerializer types used by any Service
Contracts in the assembly

We used it to create files called proxy.cs and output.config. we added proxy.cs in whole to our project, and copied the meat of output.config to our app.config. Here is the result.

proxy.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:2.0.50727.1318
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------



[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
[System.ServiceModel.ServiceContractAttribute(Namespace="MyService", ConfigurationName="IMyContractInterface")]
public interface IMyContractInterface
{
    
    [System.ServiceModel.OperationContractAttribute(Action="MyService/IMyContractInterface/SayHello", ReplyAction="MyService/IMyContractInterface/SayHelloResponse")]
    string SayHello(string name);
    
    [System.ServiceModel.OperationContractAttribute(Action="MyService/IMyContractInterface/AllCaps", ReplyAction="MyService/IMyContractInterface/AllCapsResponse")]
    string AllCaps(string str);
    
    [System.ServiceModel.OperationContractAttribute(Action="MyService/IMyContractInterface/AllLower", ReplyAction="MyService/IMyContractInterface/AllLowerResponse")]
    string AllLower(string str);
}

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public interface IMyContractInterfaceChannel : IMyContractInterface, System.ServiceModel.IClientChannel
{
}

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public partial class MyContractInterfaceClient : System.ServiceModel.ClientBase<IMyContractInterface>, IMyContractInterface
{
    
    public MyContractInterfaceClient()
    {
    }
    
    public MyContractInterfaceClient(string endpointConfigurationName) : 
            base(endpointConfigurationName)
    {
    }
    
    public MyContractInterfaceClient(string endpointConfigurationName, string remoteAddress) : 
            base(endpointConfigurationName, remoteAddress)
    {
    }
    
    public MyContractInterfaceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) : 
            base(endpointConfigurationName, remoteAddress)
    {
    }
    
    public MyContractInterfaceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) : 
            base(binding, remoteAddress)
    {
    }
    
    public string SayHello(string name)
    {
        return base.Channel.SayHello(name);
    }
    
    public string AllCaps(string str)
    {
        return base.Channel.AllCaps(str);
    }
    
    public string AllLower(string str)
    {
        return base.Channel.AllLower(str);
    }
}

And our app.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
        <bindings>
            <basicHttpBinding>
                <binding name="ConsoleService" closeTimeout="00:01:00" openTimeout="00:01:00"
                    receiveTimeout="00:10:00" sendTimeout="00:01:00" allowCookies="false"
                    bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard"
                    maxBufferSize="65536" maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
                    messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered"
                    useDefaultWebProxy="true">
                    <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                        maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                    <security mode="None">
                        <transport clientCredentialType="None" proxyCredentialType="None"
                            realm="" />
                        <message clientCredentialType="UserName" algorithmSuite="Default" />
                    </security>
                </binding>
            </basicHttpBinding>
        </bindings>
        <client>
            <endpoint address="http://localhost:8001/WCFConsoleHostedService/ConsoleService"
                binding="basicHttpBinding" bindingConfiguration="ConsoleService"
                contract="IMyContractInterface" name="ConsoleService" />
        </client>
    </system.serviceModel>
</configuration>

The tool tends to do it in a very verbose manner. As you can see, lots of options specified. the the manes ones are, for us today, the address, bindings and such. Now, when the proxy constructor is called, it does all the plumbing work allow use of the server.

Next episode is adding some tracing to our config file so we can understand what is going on. But it's friday, golf and the pool call my name over the weekend. Until later....

Technorati Tags: wcf, visual studio, dot net

Why write code when we can specify our services administratively in XML?

Steve Loethen — Thu, 21 Jun 2007 19:16:48 GMT

Okay, that was a joke. I like writing code. I am not trying to get rid of coders. Okay, trust me?

One of the interesting features of WCF is the ability to do the Address and Binding portion of our 3 legged stool administratively. In a xml file called app.config or web.config. This allows some interesting possibilities of changing the service endpoint without changing code. Being able to take a project from development to QA to production (assuming all is well with it) without a recompile to redirect the address is pretty handy. And the ability to add an additional endpoint, at a different address, with a different binding, on the same service has even more advantages.

I decided to keep my original project and just add a second server to the solution. This one is just a mirror copy of the first initially. I called it WCFConsoleServerCfg.

If we were to try and run both now, we would get a exception, due to the fact that both would try and grab port 8000. So we will need change that.

Once again, let's take the easy way first. The goal is to create a service that does exactly the same thing as our previous one, at a different address, but use the app.config to set up our service.

First, let's visit the code required...

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Linq;
using System.Text;

namespace WCFConsoleServerCfg
{
    class Program
    {
        static void Main(string[] args)
        {
            ServiceHost host = new ServiceHost(typeof(WCFContract.myContractImplementation));

            host.Open();

            Console.WriteLine("Press <ENTER> to terminate the service <app.config> host");
            Console.ReadLine();

            host.Close();
        }
    }
}

Hopefully you noticed that there is less code in the Main. And the constructor for the ServiceHost uses less parameters. What is missing is more important in this context than what is there.

First, there is not specification or create of a EndpointAddress. No port number, no URI... Second, we are not telling the ServiceHost what kind of binding to use. Those settings were put in our app.config file. Let's wander over there.

Here is what my app.config looks like:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
    <services>
      <service behaviorConfiguration="basicService" name="WCFContract.myContractImplementation">
        <endpoint address="ConsoleService" binding="basicHttpBinding" name="ConsoleService" contract="WCFContract.IMyContractInterface"/>
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:8001/WCFConsoleHostedService"/>
          </baseAddresses>
        </host>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="basicService">
        </behavior>
      </serviceBehaviors>
    </behaviors>
</system.serviceModel>
</configuration>

As you can see, we have defined the endpoint and the binding here in this config file. The name we gave it was WCFContract.myContractImplementation. Our ServiceHost constructor was fed this name, and it came here to get the info. We gave the endpoint a address of "ConsoleService", which it combines with the baseaddress of http://localhost:8001/WCFConsoleHostedService. We told it what interface to use. We also have added a behavior, called "basicService", but haven't added any behaviors to it yet. That is a place holder.

Now, how do we get our client to talk to this service? Simply change the address in our Client to reflect 8001 instead of port 8000. In our next chapter we will retool the client to use it's app.cofig to get to the service.

Technorati Tags: wcf, dot net, visual studio

» Microsoft Tech Summit: The ‘non-fanboys’ descend on Redmond | All about Microsoft | ZDNet.com

Steve Loethen — Fri, 30 Mar 2007 14:56:00 GMT

Looks like MTS is generating some significant press...

Link to » Microsoft Tech Summit: The ‘non-fanboys’ descend on Redmond | All about Microsoft | ZDNet.com

This event, in it's third year, has become a very interesting endeavor. As a Microsoft associate, it is often hard not to get defensive about the company that you love and pays your bills. But in each of the last three years, we have found a venue that we can have frank, not rhetoric filled discussions. All of you that came as guests and were willing to get in our face in a constructive way, thank you.

I can't promise anything I say will change Microsoft (I hope, but hope and promise are two different things), but I can tell you each of the blogs, the reply emails, the reviews of the speakers are being taken very seriously by folk at Redmond.

Free Online Training...

Steve Loethen — Mon, 26 Mar 2007 16:36:00 GMT

If there is anyone out there that reads this, I have a opportunity for you.

I want to offer you free access to four courses of your choice from our premium E-Learning Course Collections.

This is a $159 provided free to you.

Whether you are interested in creating Windows forms, building Web applications, implementing Data Access, or finding out about Visual Studio Team System, you can access the e-learning topic you want, when you want it, and learn at your own pace. Each lesson includes hands-on virtual labs and offline functionality.

Taking advantage of this offer is easy. Each Microsoft E-Learning Collection includes several individual courses and/or workshops. Follow the Course Collection links below to determine the right course(s) for your learning needs. Then follow these activation instructions below.

This offer expires June 30, 2007. Be sure to access your free e-learning today!

Instructions to Access Free Microsoft E-Learning

1) Go http://www.microsoft.com/learning/access

2) Input your access code: (The code is case sensitive) (and it is now correct, the training folk gave me the wrong number)

ACCESS CODE: 6691-USDPENC-9594

3) You will be prompted to sign-in using a valid Microsoft Passport ID (this will be the username and password you will use to access the site each time you log in). If you already have a profile on microsoft.com, use that Passport ID. If you do not have a Passport ID click “Register” to create one.

4) From the “Thank You” page, click on My Learning to see the list of available courses.

5) For E-Learning, click on a course title to launch the offering.

o You will then be presented with a description tab and a content tab. Read all the course requirements and description.

o Please note: Review the “system requirements” tab to be sure your computer is properly configured to access virtual labs.

o From the “Content Tab”, click on a lesson to begin training.

6) When you return to the site, please click on the following link: http://www.microsoft.com/learning/mylearning and sign in using your Microsoft Passport ID. Then click on “My Learning” to access content and continue your learning path.

If you have problems accessing the E-Learning, please contact the Microsoft e-learning support center at: 1-877-383-2829.