Las url de los servicios de este ejemplo serán estas:

• http://localhost/RestServices/MyClass/All.json
• http://localhost/RestServices/MyClass/All.xml
• http://localhost/RestServices/MyClass/Get/1.json
• http://localhost/RestServices/MyClass/Get/1.xml
• http://localhost/RestServices/MyClass/GetByName/Nombre%201.json
• http://localhost/RestServices/MyClass/GetByName/Nombre%201.xml
• http://localhost/RestServices/MyClass/Put.json
• http://localhost/RestServices/MyClass/Put.xml
• http://localhost/RestServices/MyClass/Delete.json
• http://localhost/RestServices/MyClass/Delete.xml

Lo único que tienes que hacer es crear un nuevo proyecto MVC, modificar el Global.asax con las rutas y añadir el controlador.

El código de ejemplo:

Esta clase es de ayuda para el ejemplo, nada especial

public class MyClassHelper

{

    private static List<MyClass> DataList = null;

    public class MyClass

    {

        public string Id { get; set; }

        public string Name { get; set; }

    }

    public static List<MyClass> Data 

    {

        get 

        {

            if (DataList == null)

            {

                DataList = new List<MyClass>();

                for (int i = 0; i < 10; i++)

                {

                    DataList.Add(new MyClass { Id = i.ToString(), Name = "Nombre " + i });

                }

            }

            return DataList;

        }

    }

    public static string MyClassToXml(MyClass c)

    {

        XmlSerializer ser = new XmlSerializer(typeof(MyClass));

        StringWriter sw = new StringWriter();

        ser.Serialize(sw, c);

        sw.Flush();

        sw.Close();

        return sw.ToString();

    }

    public static string MyClassToXml(List<MyClass> c)

    {

        XmlSerializer ser = new XmlSerializer(typeof(List<MyClass>));

        StringWriter sw = new StringWriter();

        ser.Serialize(sw, c);

        sw.Flush();

        sw.Close();

        return sw.ToString();

    }

    public static MyClass XmlToMyClass(string xml)

    {

        StringReader sr = new StringReader(xml);

        XmlSerializer ser = new XmlSerializer(typeof(MyClass));

        return (MyClass)ser.Deserialize(sr);

    }

    public static string MyClassToJson(MyClass c)

    {

        return JsonConvert.SerializeObject(c);

    }

    public static string MyClassToJson(List<MyClass> c)

    {

        return JsonConvert.SerializeObject(c);

    }

    public static MyClass JsonToMyClass(string Json)

    {

        return JsonConvert.DeserializeObject<MyClass>(Json);

    }

}

Esta es la clase del Global.asax, aquí es donde se definen las rutas, veas que hay dos, una para el All, Put y Delete y otra para el Get y GetByName, con el id

public static void RegisterRoutes(RouteCollection routes)

{

    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

    routes.MapRoute(

       "Default", // Route name

       "{controller}/{action}.{format}", // URL with parameters

       new { controller = "Home", action = "Index", format = UrlParameter.Optional } // Parameter defaults

   );

    routes.MapRoute(

        "WithID", // Route name

        "{controller}/{action}/{id}.{format}", // URL with parameters

        new { controller = "Home", action = "Index", id = UrlParameter.Optional, format = UrlParameter.Optional } // Parameter defaults

    );

}

Este es el controlador, aquí definimos los metodos que reciben los parámetros que hemos definido en el Global.asax

public class MyClassController : Controller

{

    public string All(string format)

    {

        List<MyClassHelper.MyClass> result = MyClassHelper.Data;

        if (format.ToLower() == "xml")

        {

            return MyClassHelper.MyClassToXml(result);

        }

        else

        {

            return MyClassHelper.MyClassToJson(result);

        }

    }

    public string Get(string id, string format)

    {

        MyClassHelper.MyClass result = MyClassHelper.Data.Where(c => c.Id == id).FirstOrDefault();

        if (format.ToLower() == "xml")

        {

            return MyClassHelper.MyClassToXml(result);

        }

        else

        {

            return MyClassHelper.MyClassToJson(result);

        }

    }

    public string GetByName(string id, string format)

    {

        List<MyClassHelper.MyClass> result = MyClassHelper.Data.Where(c => c.Name == id).ToList();

        if (format.ToLower() == "xml")

        {

            return MyClassHelper.MyClassToXml(result);

        }

        else

        {

            return MyClassHelper.MyClassToJson(result);

        }

    }

    public string Put(string format)

    {

        MyClassHelper.MyClass c;

        using (var reader = new StreamReader(Request.InputStream))

        {

            if (format.ToLower() == "xml")

            {

                c = MyClassHelper.XmlToMyClass(reader.ReadToEnd());

            }

            else

            {

               c = MyClassHelper.JsonToMyClass(reader.ReadToEnd());

            }

        }

        var v = from myc in MyClassHelper.Data where myc.Id == c.Id select myc;

        if (v.Count() == 0)

            MyClassHelper.Data.Add(c);

        else

            v.First().Name = c.Name;

        return "OK";

    }

    public string Delete(string format)

    {

        MyClassHelper.MyClass c;

        using (var reader = new StreamReader(Request.InputStream))

        {

            if (format.ToLower() == "xml")

            {

                c = MyClassHelper.XmlToMyClass(reader.ReadToEnd());

            }

            else

            {

                c = MyClassHelper.JsonToMyClass(reader.ReadToEnd());

            }

        }

        MyClassHelper.Data.Remove(c);

        return "OK";

    }

}

Y listo, eso es todo

Cada vez queda menos para que tengamos disponible la nueva versión de VS, junto con .NET Framework 4.0, C# 4.0, ASP.NET 4.0 etc, así que lo mejor es irse preparando, por ese motivo la gente de Microsoft lanza los “Kits de Entrenamiento”.

 Aquí podéis encontrar el ultimo, de Octubre, en el encontraremos, presentaciones, demos y ejemplos de:

C# 4.0, Visual Basic 10, F#, Parallel Extensions, Windows Communication Foundation, Windows Workflow,Windows Presentation Foundation, ASP.NET 4, Windows 7, Entity Framework,ADO.NET Data Services, Managed Extensibility Framework y Visual Studio Team System.

Así que no falta de nada

Para implementarla solo tenemos que crear una clase que herede de System.Web.Services.Protocols.SoapExtension. Aquí tienes un ejemplo sacado de la documentación de MSDN, intercepta los mensajes en la entrada duespues de serializar (Paso 2 en el gráfico) y en la salida antes de Deserializar (Paso 4 en el gráfico) y guarda los mensajes en disco.

public class TraceExtension : SoapExtension
{

    Stream oldStream;
    Stream newStream;
    string filename;

    // Save the Stream representing the SOAP request or SOAP response into
    // a local memory buffer.
    public override Stream ChainStream( Stream stream ){
        oldStream = stream;
        newStream = new MemoryStream();
        return newStream;
    }

    // When the SOAP extension is accessed for the first time, the XML Web
    // service method it is applied to is accessed to store the file
    // name passed in, using the corresponding SoapExtensionAttribute.
    public override object GetInitializer(LogicalMethodInfo methodInfo,
	                                   SoapExtensionAttribute attribute)
    {
        return ((TraceExtensionAttribute) attribute).Filename;
    }

    // The SOAP extension was configured to run using a configuration file
    // instead of an attribute applied to a specific XML Web service
    // method.
    public override object GetInitializer(Type WebServiceType)
    {
      // Return a file name to log the trace information to, based on the
      // type.
      return "C:\\" + WebServiceType.FullName + ".log";
    }

    // Receive the file name stored by GetInitializer and store it in a
    // member variable for this specific instance.
    public override void Initialize(object initializer)
    {
        filename = (string) initializer;
    }

    //  If the SoapMessageStage is such that the SoapRequest or
    //  SoapResponse is still in the SOAP format to be sent or received,
    //  save it out to a file.
    public override void ProcessMessage(SoapMessage message)
    {
        switch (message.Stage) {
        case SoapMessageStage.BeforeSerialize:
            break;
        case SoapMessageStage.AfterSerialize:
            WriteOutput(message);
            break;
        case SoapMessageStage.BeforeDeserialize:
            WriteInput(message);
            break;
        case SoapMessageStage.AfterDeserialize:
            break;
        default:
             throw new Exception("invalid stage");
        }
    }

    public void WriteOutput(SoapMessage message){
        newStream.Position = 0;
        FileStream fs = new FileStream(filename, FileMode.Append,
                                       FileAccess.Write);
        StreamWriter w = new StreamWriter(fs);

        string soapString =
          (message is SoapServerMessage) ? "SoapResponse" : "SoapRequest";
        w.WriteLine("-----" + soapString + " at " + DateTime.Now);
        w.Flush();
        Copy(newStream, fs);
        w.Close();
        newStream.Position = 0;
        Copy(newStream, oldStream);
    }

    public void WriteInput(SoapMessage message){
        Copy(oldStream, newStream);
        FileStream fs = new FileStream(filename, FileMode.Append,
                                       FileAccess.Write);
        StreamWriter w = new StreamWriter(fs);

        string soapString = (message is SoapServerMessage) ?
                            "SoapRequest" : "SoapResponse";
        w.WriteLine("-----" + soapString +
                    " at " + DateTime.Now);
        w.Flush();
        newStream.Position = 0;
        Copy(newStream, fs);
        w.Close();
        newStream.Position = 0;
    }

    void Copy(Stream from, Stream to)
    {
        TextReader reader = new StreamReader(from);
        TextWriter writer = new StreamWriter(to);
        writer.WriteLine(reader.ReadToEnd());
        writer.Flush();
    }
  }
}

Para poder insertar la SoapExtension en la entrada y salida de un WebMethod hay que crear una clase que herede de SoapExtensionAttribute cuya propiedad ExtensionType le dice al framework que clase SoapExtension utilizar. También tiene una propiedad Priority para que en caso de que haya más de un SoapExtension el sistema sepa en que orden ejecutarlas:

  // Create a SoapExtensionAttribute for the SOAP Extension that can be
  // applied to an XML Web service method.
 [AttributeUsage(AttributeTargets.Method)]
 public class TraceExtensionAttribute : SoapExtensionAttribute {

   private string filename = "c:\\log.txt";
   private int priority;

   public override Type ExtensionType {
       get { return typeof(TraceExtension); }
   }

   public override int Priority {
       get { return priority; }
       set { priority = value; }
   }

   public string Filename {
       get {
           return filename;
       }
       set {
           filename = value;
       }
   }

Para que un WebMethod utilice la SoapExtension solo queda aplicar el SoapExtensionAttribute al método:

[WebMethod]
[TraceExtension()]
public string MetodoWeb(string str)
{
    return "Hola";
}

Cuando pasamos una aplicación ASP.NET a Producción, el fallo mas tonto y el mas habitual que cometemos es no modificar los valores del fichero web.config que hacen que la aplicación corra en modo depuración, eso hace que nuestra aplicación sea lenta como una tortuga

Hay un truco para tener el servidor de producción configurado de manera que cualquier aplicación ASP.NET que se instale no corra en modo depuración, esto se consigue modificando el machine.config del servidor (C:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG) de la siguiente manera:

<configuration>
    <system.web>
          <deployment retail=”true”/>
    </system.web>
</configuration>

Con esta configuración el servidor, al ejecutar las aplicaciones ASP.NET, no tendrá en cuenta los valores debug, trace y enableCustomErrors del archivo de configuración de la aplicación y se ejecutara siempre con estos valores:

· debug=false

· trace=false

· enableCustomErrors=RemoteOnly

Como debe ser en producción

Por ejemplo, que queremos tener nuestra configuración especifica en un fichero aparte para que sea menos lioso

Que queremos tener las cadenas de conexión de SQL en otro sitio

Esto nos permite tener un web.config menos lioso, dejar que gente de menos nivel configure las aplicaciones sin tocar el web.config e incluso pasar a producción sin tener que acordarte de todos los cambios que tienes que hacer en el web.config.

Para los que no lo conozcan JQuery permite seleccionar y manipular elementos HTML con poquísimas líneas de código.

Aquí tenéis unos ejemplos de como JQuery se integra perfectamente con ASP.NET AJAX.

VS 2008 Web Development Hot-Fix

Han publicado en ASP.NET las Microsoft ASP.NET 3.5 Extensions Preview

En la versión cabe destacar la inclusión del MVC, El Entity Framework, los Data Services y algunos controles para SilverLight

1- Añadir un Script Manager e indicarle que los PageMethods están activos:

<asp:ScriptManager ID="ScriptManager1"
 runat="server"  EnablePageMethods="true"/>

2-El Método que queremos ejecutar tiene que ser estático y estar marcado con el atributo [WebMethod]

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
    }

    [WebMethod]
    public static string GetHello(string Name)
    {
        return "Hello " + Name;
    }
}

3- Creamos las funciones en Javascript, la estructura sera PageMethods.NombreDelMetodo y recibe como parametros los del metodo mas los manejadores

<script  type="text/javascript" language="javascript">
 function ClientGetHello(){
   PageMethods.GetHello($get("TextBox1").value,
    onCallbackComplete,
    onCallbackError,
    onCallbackError);
}

 function onCallbackComplete(result){
     alert(result);
}

 function onCallbackError(){
     alert('Se ha producido un Error');
}
</script>

4-Ya podemos usar ese método desde la parte cliente

<div id="MyDiv">
     <input id="Button1" type="button" value="button"
  onclick="JavaScript:ClientGetHello();"/>
     <asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>
 </div>

Podéis probar con este código, la primera vez tardara 5 segundos, pero durante el siguiente minuto, para el mismo Texto, será instantáneo:

WebMethod(CacheDuration=60)]
 public int CountChars(string Text)
 {
     System.Threading.Thread.Sleep(5000);
     return String.IsNullOrEmpty(Text) ? 0 : Text.Length;
 }

Ojo que las peticiones vía POST no se guardan en el cache y la pagina de pruebas de los servicios web funciona con POST, así que debes probarlo o bien por SOAP o bien por GET.

Por defecto los servicios web llevan el GET y el POST desactivado, para activarlos solo tenéis que añadir esto dentro de <system.web> en el Web.config:

<webServices>
   <protocols>
      <add name="HttpGet"/>
      <add name="HttpPost"/>
   </protocols>
</webServices>