Longhorn Indigo

[Service]
public class OrderProcessor
{
	[ServiceMethod]
	public void Place (string CustomerName, string  ProductName, int Quantity);
	{
		// Process Order
	}
}

public class Host
{
	public static void Main(string[] args)
	{
		Port port = new Port(new PortAddress("http://myServer"));
		port.Services.Add(new ServiceAddress("/OrderProcessor"), typeof(OrderProcessor));
	}
}

[ServiceSecurity()]
[Service]
public class OrderProcessor
{
	[TransactionCoupling()]
	[ServiceMethod]
	public void Place (string CustomerName, string  ProductName, int Quantity);
	{
		// Process Order
	}
}

[ServiceInterface]
public class IOrderProcessor
{
	[ServiceMethod]
	public void Place (string CustomerName, string ProductName, int Quantity);
	{
		// Process Order
	}
}

public interface IOrderProcessorChannel : IOrderProcessor, IChannel
{
}

public class Buyer
{
	public static void Main(string[] args)
	{
		Port port = new Port();
		IOrderProcessorChannel service =
			port.CreateChannel("http://myServer/OrderProcessor");
		service.Place("Ryan", "Laptop", 1);
		service.Close();
	}
}

[DataContract]
public class OrderInfo
{
	[DataMember]
	public string CustomerName;

	[DataMember]
	public string ProductName;

	[DataMember]
	public int Quantity;
}

[ServiceInterface]
public interface IOrderStatus
{
	[ServiceMethod(OneWay = true)]
	void Accepted();

	[ServiceMethod(OneWay = true)]
	void Rejected();
}

[ServiceInterface]
public interface IOrderProcessor : IDuplexContract
{
	[ServiceMethod(OneWay = true)]
	void Place(OrderInfo order);
}

[Service]
public class OrderProcessor : IOrderProcessor
{
	private IOrderStatus _Callback;
	public IOrderStatus Callback
	{
		get { return _Callback; }
		set { _Callback = Callback; }
	}

	public void Place(OrderInfo order)
	{
		bool OrderStatus = true;

		//Process order

		if (OrderStatus)
		{
			_Callback.Accepted();
		}
		else
		{
			_Callback.Rejected();
		}
	}
}

public static void Main(string[] args)
{
	Port port = new Port();
	IOrderProcessorChannel service =
		port.CreateChannel("http://myServer/OrderProcessor");
	service.Callback = (IOrderStatus) new Buyer(service);

	OrderInfo laptop = new OrderInfo();
	laptop.CustomerName = "Ryan";
	laptop.ProductName = "Laptop";
	laptop.Quantity = 1;

	service.Place(laptop);
}

public void Accepted()
{
	// Process successful order
	_service.Close();
}

public void Rejected()
{
	// Process failed order
	_service.Close();
}

[XmlTypeAttribute(Namespace = "http://schemas.Routing.com")]
[XmlRootAttribute("Route", Namespace = "http://schemas.Routing.com")]
public class Route
{
	[XMLAttribute]
	publid string Name;

	[XMLAttribute]
	public string Action;
}

[CLSCompliant(false)]
[Service]
public class Router
{
	[ServiceMethod(Format = ServiceFormatter.XmlSerializer)]
	public void AddRoute(Route route)
	{
		//Add Route to Router Table
	}

	[ServiceMethod(OneWay = true, unmachedMessagehandler = true, Format = ServiceFormatter.Message)]
	public void AllOtherMessages(Message message)
	{
		//Route Messages
	}

[SeriviceInterface(ActionBaseUri = "IRouter")]
public interface ISendGreetings
{
	[ServiceMethod(Format = ServiceFormatter.XmlSerializer)]
	void AddRoute(Route route);

	[ServiceMethod(OneWay = true)]
	void Greeting(string greeting);

	[ServiceMethod(OneWay = true)]
	void Salutations(int count, string greeting);

Port port = new Port();
ISendGreetingsChannel service =
	port.CreateChannel("http://myServer/SendGreetings");

Route route = new Route();
route.Name = "Greeting";
route.Action = "action*=Greeting,route=NewEngland";
channel.AddRoute(route);
			
route.Name = "Salute";
route.Action = "action*=Salutations,route=SouteEast";
service.AddRoute(route);

[Service]    
public class OrderProcessor
{
	[ServiceMethod]
	public void PlaceOrderByName(string CustomerName, string ProductName, int Quantity)
	{            
		// Process order
		return 42;
	}

[ServiceMethod(AsyncPattern = true)]
public IAsyncResult BeginPlaceOrderByNumber(string CustomerName, 
	int ProductNumber, 
	int Quantity,
	AsyncCallback callback,
	object state)
{
	OrderAsyncResult orderResult = new OrderAsyncResult(...);

	return orderResult;
}

[ServiceMethod]
public void EndPlaceOrderByNumber(IAsyncResult result)
{
	OrderAsyncResult asyncResult = (OrderAsyncResult)result;
	asyncResult.AsyncWaitHandle.WaitOne();
}

[ServiceMethod(OneWay = true)]
public void EmailStatus(string CustomerName, string EmailAddress)
{
	// Queue request to email the customer their status at some point
}

[ServiceMethod]
int PlaceOrderByName(string CustomerName,
	string ProductName,
	int Quantity);
		
[ServiceMethod(AsyncPattern = true)]
IAsyncResult BeginPlaceOrderByName(string CustomerName, 
	string ProductName, 
	int Quantity,
	AsyncCallback callback,
	object asyncState) ;

[ServiceMethod]
int PlaceOrderByNumber(string CustomerName,
	int ProductNumber,
	int Quantity);