Brad Abrams : SLAR

Business Apps Example for Silverlight 3 RTM and .NET RIA Services July Update: Part 23: Azure

BradA — Fri, 21 Aug 2009 23:10:24 GMT

Still updating my Mix 09 Silverlight 3 + RIA Services talk with more fun stuff. Azure represents a general trend in the industry towards a cloud computing model. As much as I love the development phase of projects, the operations side is often the most cost intensify part. With economies of scale, cloud computing has the potential to greatly reduce those costs. I think example I took advantage of Windows Azure to host the web-tier of the application and Sql Azure to host the data. Those are actually independent decisions. You could decide to host one and not the other.

You can see the full series here.

The demo requires (all 100% free and always free):

VS2008 SP1
Silverlight 3 RTM
.NET RIA Services July '09 Preview
Windows Azure Tools for Microsoft Visual Studio July 2009 CTP
Windows Azure Invitation (apply here)
Sql Azure Invitation (apply here)

Check out the live site (of course, hosted on Azure) Also, download the full demo files

So in this example, I can going to move the data from on premises Sql Server to SQL Azure AND move the applogic code from running on my own web server to running on Windows Azure. The main client will stay Silverlight.

Setting up SQL Azure

Once you get an invite code for SQL Azure, you can go to http://sql.azure.com and add a new database, just by clicking add new Database

Then you get a nice connection string..

Then you need to populate the database. If you have an existing database, the best way to do this likely to use Sql Management Studio to get a Sql script and then using ADO.NET to execute that script on this Sql Azure database.

But for no good reason, I wrote a very simple bit of ADO.NET code to read the data out of my local database and insert it into the Sql Azure based one. You can find it in the default.aspx.cs page if you want to check it out.

Setting up Windows Azure

That sets up our database in the cloud, now let’s create a place for our web application to run. Once you get an invite code from Windows Azure you can go in an setup your service. Go to windows.Azure.com and add a new service

Select the Hosted Service

Setting up the Project

Start up Visual Studio as an administrator… the “local cloud” support requires this right now.

Then create a new Cloud Service

For this example, all we need is a Web Role

I renamed “WebRole1” to MyApp.Web to match the pervious examples.

Hitting F5 starts up the “local cloud” and runs it there..

Creating the Application

Now, let’s start building the application. First let’s build out the data layer. I already had a Linq2Sql model from a pervious example, so I just copied that. I did tweek a few of the datatypes to match what I loaded into Azure… Entity Framework would have worked just as well.

Then I changed the connection string in Web.config to match the connection strings of the Sql Azure database.

<add name="NORTHWNDConnectionString" connectionString="Server=tcp:jyfmd9f7te.ctp.database.windows.net;Database=northwind;User ID=[add userid];Password=[add password];Trusted_Connection=False;"

  providerName="System.Data.SqlClient" />

Now it is just like the original walk through..

Create the Service

Write some code in it…

public IQueryable<SuperEmployee> GetSuperEmployees()

    return this.Context.SuperEmployees

               .Where(emp => Convert.ToInt32(emp.Issues) > 100)

               .OrderBy(emp => emp.EmployeeID);

public void InsertSuperEmployee(SuperEmployee superEmployee)

    this.Context.SuperEmployees.InsertOnSubmit(superEmployee);

public void UpdateSuperEmployee(SuperEmployee currentSuperEmployee)

    this.Context.SuperEmployees.Attach(currentSuperEmployee, this.ChangeSet.GetOriginal(currentSuperEmployee));

Now we need to add a Silverlight Project

And associate it with the MyApp.Web project and enable RIA Services.

Now you can simply use the exact same Silverlight client we built before.

You get sorting, paging, filtering, validated editing, batching all with no plumbing code and now, all hosted in cloud!

Deploying to the Cloud

Now that we have our app done, let’s deploy it to the cloud.

First we need to create the deployment package. To do that right click on the MyApp.CloudService project and Select Publish

The publish directory will up in explorer with your application deployment package and a separate settings file

The deployment package is just a zip file that contains the silverlight xap an the code and resources to execute on the server. The settings file contains things like number of front-end servers you want to create, etc.

Now, go back to windows.azure.com and select the project we created earlier.

There are two places for your app to run.. Staging and Production. The idea is you can do testing in the real environment before you switch your live site over.

Select upload to add your project to staging.

Select deploy..

The add the package and settings and give it some deployment label to help us keep track of its movements between staging and production.

Then click run to start the instance running. Then it will say “initializing…” for a few minutes

Finally, when it says “started” you can run the app by clicking on the test link:

Next swap this into the deployment stage and you are live!

And we are done!

In this section we talked about how to deploy your RIA Services application to the cloud using Sql Azure for the data and Windows Azure for the web tier. You can mix and match those however you want.

Also, check out Nikhil’s example on Azure, it uses Windows Azure table storage which is very cool as well.

Review for SLAR vol2

BradA — Fri, 06 Jan 2006 07:58:00 GMT

The .NET Framework Standard Library Annotated Reference, Volume 2 gets a well thought out review from Mike Riley on www.AspNetPro.com . Mike does a good job of highlighting what I think is the core value of the book – and why I had so much fun working on it. As always, I’d love to hear your feedback.

PRObooks: .NET Framework Standard Library Annotated Reference Volume 2: Networking Library, Reflection Library, and XML Library

The SLAR (vol2) on System.Globalization.CultureInfo

BradA — Thu, 24 Nov 2005 02:18:00 GMT

Continuing in the series sharing some of the information in the .NET Framework Standard Library Annotated Reference Vol 1 and .NET Framework Standard Library Annotated Reference Vol 2 with some information on CultureInfo.

SS (Shawn Steele)

Always use cultures when appropriate, but be careful where you use them. They are meant to

be specific for a user or machine, and they could change. For example, as countries join the EU,

their currency symbols or formats change. In other cases, companies or users may prefer a 24-

hour clock to a 12-hour default. Culture data is necessary and great when presenting data to the

humans who are actually using the computer, but it’s an awful way to store data. If you have to

read something back later, save it in a binary format, use CultureInfo.InvariantCulture,

or specify a specific format to the formatting functions. Except for Invariant, don’t expect the

culture data provided by this class to remain the same, even between instances running as the

same user.

IA (Ihab Abdelhalim)

One of my biggest regrets is that CultureInfo.ClearCachedData() is an instance method

rather than a static method. This method actually clears shared (static) caches for system

settings like CurrentCulture, CurrentRegion, and the like. It does nothing to individual

instances, so it is very confusing to have this as an instance method. Unfortunately, this was

discovered very late in the .NET Framework cycle, and it was considered a breaking change to

make it static, so it had to ship this way.

using System;

using System.Globalization;

/// <summary>

/// Sample demonstrating the use of the CultureInfo class.

/// Use this class to retrieve information about a specific culture, such as

/// date/time formats and number formats.

/// </summary>

internal class CultureInfoSample

{

private static void Main()

{

Console.WriteLine("Summary for the current thread culture:");

WriteCultureInfoSummary(CultureInfo.CurrentCulture);

Console.WriteLine("Summary for the current thread UI culture:");

WriteCultureInfoSummary(CultureInfo.CurrentUICulture);

Console.WriteLine("Summary for the operating system UI culture:");

WriteCultureInfoSummary(CultureInfo.InstalledUICulture);

Console.WriteLine();

Console.WriteLine("Press Enter to continue");

Console.ReadLine();

}

// Writes a summary of the specified CultureInfo to the console.

private static void WriteCultureInfoSummary(CultureInfo info)

{

Console.WriteLine(" Culture name: {0} ({1})",

info.DisplayName, info.Name);

WriteDateTimeFormatInfoSummary(info.DateTimeFormat);

WriteNumberFormatInfoSummary(info.NumberFormat);

Console.WriteLine();

}

// Writes a summary of the specified DateTimeFormatInfo to the console.

private static void WriteDateTimeFormatInfoSummary(DateTimeFormatInfo info)

{

Console.WriteLine(

" Long date/time pattern: {0} {1}",

info.LongDatePattern, info.LongTimePattern);

Console.WriteLine(

" Short date/time pattern: {0} {1}",

info.ShortDatePattern, info.ShortTimePattern);

Console.WriteLine(

" AM/PM designators: {0}/{1}",

info.AMDesignator, info.PMDesignator);

}

// Writes a summary of the specified NumberFormatInfo to the console.

private static void WriteNumberFormatInfoSummary(NumberFormatInfo info)

{

Console.WriteLine(

" Currency symbol: {0}", info.CurrencySymbol);

Console.WriteLine(

" Percent symbol: {0}", info.PercentSymbol);

Console.WriteLine(

" Negative sign: {0}", info.NegativeSign);

Console.WriteLine(

" Positive sign: {0}", info.PositiveSign);

Console.WriteLine(

" Decimal separator: {0}", info.NumberDecimalSeparator);

Console.WriteLine(

" Thousands separator: {0}", info.NumberGroupSeparator);

}

The output is

Summary for the current thread culture:

Culture name: English (United States) (en-US)

Long date/time pattern: dddd, MMMM dd, yyyy h:mm:ss tt

Short date/time pattern: M/d/yyyy h:mm tt

AM/PM designators: AM/PM

Currency symbol: $

Percent symbol: %

Negative sign: -

Positive sign: +

Decimal separator: .

Thousands separator: ,

Summary for the current thread UI culture:

Culture name: English (United States) (en-US)

Long date/time pattern: dddd, MMMM dd, yyyy h:mm:ss tt

Short date/time pattern: M/d/yyyy h:mm tt

AM/PM designators: AM/PM

Currency symbol: $

Percent symbol: %

Negative sign: -

Positive sign: +

Decimal separator: .

Thousands separator: ,

Summary for the operating system UI culture:

Culture name: English (United States) (en-US)

Long date/time pattern: dddd, MMMM dd, yyyy h:mm:ss tt

Short date/time pattern: M/d/yyyy h:mm tt

AM/PM designators: AM/PM

Currency symbol: $

Percent symbol: %

Negative sign: -

Positive sign: +

Decimal separator: .

Thousands separator: ,

Press Enter to continue

The SLAR (vol2) on System.Runtime.InteropServices.CharSet

BradA — Thu, 17 Nov 2005 02:17:00 GMT

public enum CharSet

{

CF Ansi = 2,

Auto = 4,

MS CF None = 1,

Unicode = 3,

}

It’s somewhat unfortunate that CharSet.Ansi is the default behavior for PInvoke, since

managed strings and characters are internally Unicode. Win32 APIs often expose both an ANSI

and Unicode export, but by default you end up calling the ANSI one, requiring the Interop

marshaler to copy each Unicode string to a new ANSI string! In contrast, by calling the Unicode

export, the CLR can just pin the managed strings and expose them directly. You can override

the default behavior and explicitly mark each PInvoke signature with CharSet.Auto,

although in the future the CLR will provide a module-level DefaultCharSetAttribute that

allows you to select your own default for all signatures in your module.

BTW – if you like Adam’s take on the world, check out his exhaustive book on Interop…

.NET and COM: The Complete Interoperability Guide

The SLAR (vol2) on System.Runtime.CompilerServices. DecimalConstantAttribute

BradA — Thu, 10 Nov 2005 02:19:00 GMT

RJ (Rex Jaeschke)

The metadata does not directly support the representation of constants of type System.Decimal. As a result, in the code generated by the C# (and VB) compiler, they are stored as an

attribute using the type DecimalConstantAttribute. Consider the following C# code:

public class Test

{

private const decimal d = 12.3456m;

}

The relevant MSIL generated is

.field private static initonly valuetype [mscorlib]System.Decimal d

.custom instance void

[mscorlib]

System.Runtime.CompilerServices.DecimalConstantAttribute::.ctor(

uint8, uint8, uint32, uint32, uint32) = ( … hex bytes … )

This type is not intended to be used directly by programmers, but rather by compiler writers,

based on the programmer’s use of some language syntax (such as the keywords const

decimal in C#).

Note that it is expected that a future implementation of the CLI will support an alternate

representation of the decimal type, which has a much larger range, and a scale that exceeds

eight bits. As such, new constructors and methods are likely to be added to this type, as well as

to System.Decimal.

This attribute has been a hot topic in ECMA discussions. A new IEEE 128-bit decimal

representation offers more range/precision (in the same number of bits!) than the current CLR

implementation. If CLR were to support this new IEEE decimal in the future, this attribute will

present a problem because the IEEE decimal’s scale is wider than the byte type of the

constructor’s scale parameter. It is likely that the parameter types of the constructor will be

widened and/or additional constructors added in a future release to make an IEEE decimal

implementation an option for a future CLR release.

The SLAR (vol2) on System.Reflection.BindingFlags

BradA — Thu, 10 Nov 2005 02:15:00 GMT

public enum BindingFlags

{

CreateInstance = 0x200,

DeclaredOnly = 0x2,

MS Default = 0x0,

ExactBinding = 0x10000,

MS FlattenHierarchy = 0x40,

GetField = 0x400,

GetProperty = 0x1000,

IgnoreCase = 0x1,

MS IgnoreReturn = 0x1000000,

Instance = 0x4,

InvokeMethod = 0x100,

NonPublic = 0x20,

OptionalParamBinding = 0x40000,

Public = 0x10,

MS PutDispProperty = 0x4000,

MS PutRefDispProperty = 0x8000,

SetField = 0x800,

SetProperty = 0x2000,

Static = 0x8,

SuppressChangeType = 0x20000,

}

When we teach API design, we often use this enum as an example of a bad enum design. The

problem is that this enum is actually combining several different concepts: visibility selection,

member selection, binding algorithm, and so on, yet it claims to be Flags enum, which would

imply the values can be used independently or together, using the binary OR operator. This is

not the case. Just look at the documentation for this enum. It spells out several rules for the

usage of the enum. It’s probably the most complicated enum documentation in the whole

framework.

This enum has two different axes, and both must be specified when using the enum. The first is

the type of method—static or instance. The second is visibility—public or non–public. You must

specify one or both of those values when using the BindingFlags enum, and it’s remarkably

easy to forget to specify one of these. It’s a surprisingly common problem for users of

Reflection. I certainly wish we would have done something a little more explicit here.

A funny thing about the BindingFlags enum: we originally had a lot more binding flag

options (aren’t there already enough?!), which we ripped out just before RTM ship. These

included things like predefined BindingFlags combinations (BindingFlags.Private, etc.)

and more granular binding flags.

BindingFlags.IgnoreCase has some performance and working set implications associated

with it (we double the Reflection string cache and lowercase all strings passed in). If your

scenario doesn’t need it, try to avoid it.

The SLAR (vol2) on System.BadImageFormatException

BradA — Thu, 03 Nov 2005 01:15:00 GMT

You have to be careful when you pick a code name for a project as they sometimes leak out into

the final product. “Fusion” (as in the FusionLog property) is a classic example of that. Fusion

is the code name for a set of software lifecyle management infrastructure used in the CLR and

some parts of Windows. Now it is immortalized in this property that returns information about

the fusion probing history.

Some people have recently asked what this refers to—does it refer to a corrupt JPEG or bitmap,

or a corrupt file of any sort? It was meant to refer to an executable or a DLL. The name comes

from the OS loader’s terminology for a portable executable (PE) image. Perhaps in a future

version we’ll add a different exception for general file format corruption.

The SLAR (vol2) on System.Net.Authorization

BradA — Wed, 26 Oct 2005 23:18:00 GMT

Danny Thorpe

Avoid creating methods with Boolean parameters. Boolean parameters make calls harder to

read and harder to write. Quick! What’s the difference between Authorization("foo",

true) and Authorization("foo", false)? There’s no telling what those true/false

parameters do on the inside. Adding an enum type AuthorizationCompletion with

Pending and Finished members would allow those constructor calls to read

Authorization("foo", AuthorizationCompletion.Pending) and

Authorization("foo", AuthorizationCompletion.Finished). At the same time, it

might make sense for the Complete property’s type to be the same enum type as the

constructor parameters, for consistency.

using System;

using System.Net;

using System.Text;

public class AuthorizationSample

{

public static void Main()

{

String credentials = "username:password";

ASCIIEncoding e = new ASCIIEncoding();

Byte[] bytes = e.GetBytes(credentials);

String token = "BASIC " + Convert.ToBase64String(bytes);

Authorization au = new Authorization(token, false, "Group1");

String realm1 = "c:\\samples\\mytestsamples\\";

String realm2 = "c:\\data\\mytestdata\\";

String[] realms = {realm1, realm2};

au.ProtectionRealm = realms;

Console.WriteLine("Authorization Complete = {0}", au.Complete);

Console.WriteLine("Authorization ConnectionGroupId = '{0}'",au.ConnectionGroupId);

Console.WriteLine("Authorization.Message = '{0}'",au.Message);

Console.WriteLine();

Console.WriteLine("Authorization.ProtectionRealm:");

foreach (String s in au.ProtectionRealm)

{

Console.WriteLine(s);

}

The output is

Authorization Complete = False

Authorization ConnectionGroupId = 'Group1'

Authorization.Message = 'BASIC dXNlcm5hbWU6cGFzc3dvcmQ='

Authorization.ProtectionRealm:

c:\samples\mytestsamples\

c:\data\mytestdata\

The SLAR (vol2) on System.AssemblyLoadEventHandler

BradA — Thu, 20 Oct 2005 01:09:00 GMT

CF public delegate void AssemblyLoadEventHandler(object sender,AssemblyLoadEventArgs args);

Looking back on it now, there are way too many types included in the System root namespace.

This namespace is automatically important in most projects and the proliferation of types

causes some degree of developer confusion. In retrospect we should have factored System

better and put these less commonly used types into a different namespace.

The SLAR (vol2) on System.Assembly

BradA — Thu, 13 Oct 2005 01:07:00 GMT

Calling Load(AssemblyName) is not necessarily the same as calling Load(String). If the

AssemblyName.CodeBase is not set, then they do the same thing. So, if you’ve set the

AssemblyName.Name, CultureInfo, public key token/public key and/or Version

properties, it would be the same as if you had specified those properties in a String (as a

display name) and passed that to Load(String).

However, if the AssemblyName.CodeBase is set, but the AssemblyName.Name is not, then

it’s the same as calling Assembly.LoadFrom() on that AssemblyName.CodeBase. When

both the AssemblyName.CodeBase and the AssemblyName.Name are set, then the bind is

tried with all the given binding information, except the AssemblyName.CodeBase (so, again,

it’s just like calling Load(String)). If that succeeds, we’re done. But, if that fails, then the bind

is tried again with just the AssemblyName.CodeBase (just like LoadFrom()). If it fails again,

then of course the whole bind fails. But, if it succeeds, then we verify that the binding properties

in the AssemblyName match the found assembly. If they don’t match, a FileLoadException

will be thrown for HResult FUSION_E_REF_DEF_MISMATCH.

So, setting both the AssemblyName.CodeBase and the AssemblyName.Name is useful for

when you want to both load an assembly at a given path into the LoadFrom context, and verify

that it has the public key token, and so forth, that you expect. Of course, as described above

(and due to binding context rules), keep in mind that just because you call

Load(AssemblyName) with a CodeBase does not mean that it will be loaded from that path.

using System;

using System.Text;

using System.Reflection;

/// <summary>

/// This example shows how to generate ILDASM-like output for an assembly.

/// </summary>

public class AssemblySample

{

public static void Main()

{

Assembly assembly = Assembly.GetExecutingAssembly();

Console.WriteLine("ILDASM style output for '{0}'",

assembly.GetName().Name);

Console.WriteLine("---------------------------------------------");

Console.WriteLine("// Metadata version: {0}",

assembly.ImageRuntimeVersion);

foreach (AssemblyName refAssemblyName

in assembly.GetReferencedAssemblies())

{

Console.WriteLine(".assembly extern {0}", refAssemblyName.Name);

Console.WriteLine("{");

Console.WriteLine(" .publickeytoken = ({0})",

ByteArrayToHexString(refAssemblyName.GetPublicKeyToken()));

Console.WriteLine(" .ver {0}",

refAssemblyName.Version.ToString().Replace('.', ':'));

Console.WriteLine("}");

}

Console.WriteLine(".assembly {0}",assembly.GetName().Name);

Console.WriteLine("{");

foreach (Attribute attrib in assembly.GetCustomAttributes(false))

{

Console.WriteLine(" .custom instance {0}", attrib);

}

Console.WriteLine(" .hash algorithm {0}",

assembly.GetName().HashAlgorithm);

Console.WriteLine(" .ver {0}",

assembly.GetName().Version.ToString().Replace('.', ':'));

Console.WriteLine("}");

foreach (Module currentModule in assembly.GetModules())

{

Console.WriteLine(".module {0}", currentModule.Name);

}

Console.WriteLine();

Console.WriteLine("Press Enter to continue");

Console.ReadLine();

}//end main

private static string ByteArrayToHexString(byte[] values)

{

StringBuilder hexString = new StringBuilder();

foreach (byte b in values)

{

hexString.AppendFormat("{0:X}", b);

hexString.Append(' ');

}

return hexString.ToString();

}

The output is

ILDASM style output for 'Assembly'

---------------------------------------------

// Metadata version: v1.1.4322

.assembly extern mscorlib

{

.publickeytoken = (B7 7A 5C 56 19 34 E0 89 )

.ver 1:0:5000:0

}

.assembly Assembly

{

.custom instance System.Diagnostics.DebuggableAttribute

.hash algorithm SHA1

.ver 0:0:0:0

}

.module Assembly.exe

Press Enter to continue

The SLAR (vol2) on System.AppDomain

BradA — Thu, 06 Oct 2005 01:06:00 GMT

We introduced Application Domains as a lightweight process mechanism. Because managed

code can be verifiably type safe (memory safe) we did not need the heavyweight address space

barrier that processes provide. This savings works out well most of the time. However, when

using interop with unmanaged code it does cause some problems when type safety is violated.

One notable example of this is the loader-lock and AppDomain marshaling problem that C++

was susceptible to. We fixed this problem in a service pack of v1.1.

AppDomain is one of the few classes in the .NET Framework that is commonly used via COM

Interop (often for CLR hosting scenarios), so we made a point of exposing most of its

functionality via an interface called _AppDomain. Exposing a real managed interface to COM

consumers is much better than taking advantage of our regrettable “class interface”

functionality, since we avoid a host of versioning problems by being in complete control of

what gets exposed. The unfortunate thing about _AppDomain (besides the non-standard name,

which I know drives folks like Brad crazy) is that the overloaded members are still just as

clunky to use from COM. For example, the Load overloads are exposed as Load, Load_2,

Load_3, and so on. But because of the versioning benefits, expect more of our COM-visible

classes in the .NET Framework to start implementing real interfaces like _AppDomain and stop

exposing class interfaces in the future.

using System;

public class AppDomainSample

{

public static void Main()

{

AppDomain domain = AppDomain.CreateDomain("MyNewDomain");

domain.AssemblyLoad +=

new AssemblyLoadEventHandler(MyLoadHandler);

Console.WriteLine("FriendlyName is '{0}'", domain.FriendlyName);

Console.WriteLine("Attempting to execute HelloWorld.exe...");

domain.ExecuteAssembly("HelloWorld.exe");

Console.WriteLine("Finished executing HelloWorld.exe.");

AppDomain.Unload(domain);

Console.WriteLine("AppDomain unloaded.");

Console.WriteLine();

Console.WriteLine("Press Enter to continue");

Console.ReadLine();

}

public static void MyLoadHandler(object sender,

AssemblyLoadEventArgs args)

{

Console.WriteLine("Loaded assembly {0}",

args.LoadedAssembly.FullName);

}

The output is

FriendlyName is 'MyNewDomain'

Attempting to execute HelloWorld.exe...

Loaded assembly HelloWorld, Version=1.0.1767.19756, Culture=neutral, PublicKeyTo

ken=null

Loaded assembly System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, Publi

cKeyToken=b77a5c561934e089

Loaded assembly System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a

5c561934e089

Loaded assembly System.Drawing, Version=1.0.5000.0, Culture=neutral, PublicKeyTo

ken=b03f5f7f11d50a3a

Loaded assembly System.Xml, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=

b77a5c561934e089

Finished executing HelloWorld.exe.

AppDomain unloaded.

Press Enter to continue

The SLAR (vol2) on System.Reflection.AmbiguousMatchException

BradA — Thu, 29 Sep 2005 01:02:00 GMT

public sealed class AmbiguousMatchException : SystemException

{

// Constructors

public AmbiguousMatchException();

public AmbiguousMatchException(string message);

public AmbiguousMatchException(string message, Exception inner);

}

Joel Pobar

This exception is commonly thrown when input parameters to various non–plural XXXInfo/

Type methods (Type.GetMethod/GetField, etc.) result in multiple matches from the binder.

When calling these non–plural methods, it’s best to be specific in your BindingFlags and

always add type parameters for the methods that can accept them.

I’ve also seen this exception break deployed code where the code reflects on a library (loaded

by name) that is versioned out of band. To illustrate this, a brief example:

MyLibrary.dll (Version 1.0)

class Foo

{

public void MyExtensibilityPoint() {}

}

MyLibrary.dll (Version 2.0)

class Foo

{

public void MyExtensibilityPoint() {}

public void MyExtensibilityPoint(int a) {}

}

My Deployed Code:

MethodInfo m = typeof(Foo).GetMethod("MyExtensibilityPoint");

Version 2 of the MyLibrary dll is deployed with a new overload of MyExensibilityPoint

to type Foo. Rerunning “My Deployed Code” above on Version 2 of the type results in an

ambiguous match exception because we now have two methods with the same name, and

we’re not specifying the parameters of the method for binding. To avoid this scenario, always

use the GetXXX APIs and supply as many specifics as possible (in this case, supplying a type

array specifying the methods parameters), and consider including the version part when

loading the assembly/library.

SLAR2 gets a review..

BradA — Thu, 15 Sep 2005 02:43:00 GMT

Check out the recent review of the SLAR2 from http://www.larkware.com/

The SLAR (vol2) on System.Net.Sockets.AddressFamily

BradA — Tue, 06 Sep 2005 00:47:00 GMT

Looks like the SLAR vol2 finally made its way to book sealer’s warehouses which means everyone that pre-ordered should be getting their copy soon. I’d love to hear what you think and I’d encourage you to help your fellow developers by posting a review on Amazon and\or on your blog.

In honor of this day, I thought I’d restart the series sharing some of the information in the .NET Framework Standard Library Annotated Reference Vol 1 and .NET Framework Standard Library Annotated Reference Vol 2 with some information on AddressFamily (the first type in Vol2)

public enum AddressFamily

{

AppleTalk = 16,

Atm = 22,

Banyan = 21,

Ccitt = 10,

Chaos = 5,

Cluster = 24,

DataKit = 9,

DataLink = 13,

DecNet = 12,

Ecma = 8,

FireFox = 19,

HyperChannel = 15,

Ieee12844 = 25,

ImpLink = 3,

InterNetwork = 2,

InterNetworkV6 = 23,

Ipx = 6,

Irda = 26,

Iso = 7,

Lat = 14,

MS Max = 29,

NetBios = 17,

NetworkDesigners = 28,

NS = 6,

Osi = 7,

Pup = 4,

Sna = 11,

Unix = 1,

Unknown = -1,

Unspecified = 0,

VoiceView = 18,

}

Lance Olson

This list was derived mainly from the winsock header files. While the socket classes included in

v1 of the .NET Framework are mostly geared around IP-based communication, it is possible to

use the EndPoint class to support other protocols such as IPX, AppleTalk, Infra Red, and so

forth.

using System;

using System.Net;

using System.Net.Sockets;

using System.Text;

public class AddressFamilySample

{

public static void Main()

{

IPAddress ip = IPAddress.Parse("127.0.0.1");

Socket skt = new Socket(AddressFamily.InterNetwork,

SocketType.Dgram, ProtocolType.Udp);

try

{

IPEndPoint ep = new IPEndPoint(ip, 9999);

skt.Connect(ep);

byte[] req = Encoding.ASCII.GetBytes("Test");

skt.SendTo(req, ep);

IPEndPoint rep = (IPEndPoint)skt.LocalEndPoint;

Console.WriteLine("LocalEndPoint details:");

Console.WriteLine("Address: {0}", rep.Address);

Console.WriteLine("AddressFamily: {0}", rep.AddressFamily);

Console.WriteLine("Port: {0}", rep.Port);

}

catch (Exception e)

{

Console.WriteLine("Error: " + e.Message);

}

finally

{

skt.Close();

}

Console.WriteLine();

Console.WriteLine("Press Enter to continue");

Console.ReadLine();

}

The output is

LocalEndPoint details:

Address: 127.0.0.1

AddressFamily: InterNetwork

Port: 4082

Press Enter to continue

Sample Chapter from the SLARv2 posted

BradA — Thu, 25 Aug 2005 16:01:00 GMT

DevX.com recently posted a sample chapter of .NET Framework Standard Library Annotated Reference, Volume 2

They choose System.Xml.XmlReader… some good annotations on this one.

I’d love to hear your comments on this sneak peak…