Search results matching tags 'WCF' and 'ASP.NET'

Announcing my Session “Connecting Web Systems” at Advanced Developer Conference 2012

ddobric — Sat, 27 Oct 2012 12:45:15 GMT

If you are professional developer or architect who focus Microsoft technologies, then ADC is the conference of great choice. Internationally recognized and legendary experts will present most popular technology topics.
One of best things at this conference I personally like is “NO MARKETING”. All session content is pure experience with pre-filtered sponsoring and marketing noise.

At the upcoming Advanced Developer Conference 2012 in Germany I will give two session. Here is the first look on agenda for “Connecting Web Systems” session. Because this session is not related to some product, it will focus new peaces of technology at the Microsoft’s development platform. This time I decided to talk about technologies which might dramatically change the web soon. However this might also influence the way how we thing about applications and it will definitely change the architecture of future applications. As Integration MVP in last two years I was involved in some more or less hidden and still not well documented technology areas with focus on WebSockets, SignalR and communication in Web in general.
Content presented in this session is pure result of this work. You are welcome.

How to implement Implement “Async-Push” stream with ASP.NET Handler?

ddobric — Mon, 20 Aug 2012 07:20:00 GMT

The platform technology wave announced in 2012 brings a number of innovations in the ,NET and Microsoft platform at all;no question. One of my personal favorites is the peace of Platform which makes push-scenario easy adoptable. In the time of upcoming cloud patterns, there are more business and technical scenarios which require server/service to push the data to the client. Some of these technologies are to find around WebSockets and SignalR. My intension is not in this post to explain the need for “push”-demand. Assuming that this is clear I would like to provide a native an interesting example, which shows how push scenarios can be achieved by using of simple HTTP.

To demonstrate this I decided to avoid technologies like WebApi and to implement one example on the native ASP.NET. This in nothing against WebApi which I really like. If you like you can implement the same scenario based on WebApi or WCF.. However WebApi and WCF are hardly message driven by design. My scenario is nativelly stream driven and because of that it fits a bit better for this case.

Basically I want to send the request from some HTTP capable client (i.e browser) to the ASP.NET handler, which fulfills following:

1. The request cannot be completed synchronously
This means we will process request asynchronously.

2.. The amount of data sent to the client is huge stream.
This will hold an open connection between client and server. We will push stream of data through this connection from Server to client.

Interestingly, both WebSockets and SignalR makes usage of this two requirements.The WebSockets goes hard way and extend the HTTP protocol to make this working. The SignalR uses standard HTTP and makes usage of 4 transports (ServerSentEvents, ForewerFrames, Polling and WebSockets).

My idea in this post is to show how to natively implement similar scenario by yourself on top of ASP.NET. Then I want to open the browser, type in the URL and expect to continually receive some data from server for very long time without of getting a time-out. Following picture illustrate this scenario:

As first I will create the Web-Project of any type (Forms, MVC, Empty). The go to add project item and select generic handler:

This will create an empty ASHX handler:

/// <summary>

/// Summary description for Handler1

/// </summary>

public class MyStreamHandler : IHttpHandler

{

public void ProcessRequest(HttpContext context)

{
context.Response.ContentType = "text/plain";

context.Response.Write("Hello World");
}

public bool IsReusable

{
get

{

return false;

}

This is a typical ASHX handler which you probably already know. Now change this implementation as follows:

public override async Task ProcessRequestAsync(HttpContext context)
{

}

We basically replace implementation with the HttpTaskAsyncHandler which is the async version of handler. Now I will implement some code which periodically writes some data to opened request stream. In fact, physically every request causes ASP.NET to create corresponding response stream context.Response . That means common request-response, as we know it, is anyhow a stream in its deep nature. What I did in the code bellow, is async processing of the request:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Web;

namespace Daenet.WebApiSync
{
    /// <summary>
    /// Summary description for MyStreamHandler
    /// </summary>
    public class MyStreamHandler : HttpTaskAsyncHandler
    {
        #region IHttpHandler Members

        public override async Task ProcessRequestAsync(HttpContext context)
        {
            context.ThreadAbortOnTimeout = false;

            await doJobAsync(context);

        }

        private Task doJobAsync(HttpContext context)
        {
            Task t = new Task(() =>
            {
                for (int n = 0; n < 100; n++)
                {
                    context.Response.Write(String.Format("Sequence: {0} <br/>", n));
                    context.Response.Flush();
                    Thread.Sleep(500);
                }
            });

            t.Start();

            return t;
        }

        #endregion
    }
}

When the browser or any other client sends the request to the ASHX handler we immediately returns in async manner and frees the request thread. In that moment, the browser (any client) starts reading of streamed data, which is generated in doJobAsync. Note that data will not be streamed if Flush() is not called.
To test this code, open some browser and type the URL of the MyStreamHandler.ASHX:

Open the fiddler and notice the request remains open for a long time. Unfortunately ASP.NET will abort request after some time if it doesn’t complete. Usually all request are processed synchronously in more or less short time and no any developer runs into this problem. However when working with async pattern you possible process longer running jobs. In that case following line of code is required:

context.ThreadAbortOnTimeout = false;

This prevents ASP.NET pipeline to abort request which are not completed Without this line, this scenario will only work as long the request thread is not aborted.
The result in browser would look like shown at pictures below. As you see browser continually receives more and more data.

Working with Fiddler and Proxies

If you work with fiddler, pleas also notice following:

If the streaming is not enabled in Fiddler (default is OFF) the client will receive all data at once after the data are streamed into the response stream. Btw. if you work with SignalR and Fiddler you will also have to enable streaming. If you don’t do that, the SignalR will switch to the polling transport.

Console Client Application

To demonstrate the same within another HTTP client, I decided to build Console Application. Following peace of code shows the client which receives stream of data.

WebClient client = new WebClient();

Stream str = client.OpenRead(new Uri("http://localhost:3261/mystreamhandler.ashx"));

byte[] buff = new byte[100];

while (true)

{

var task = str.ReadAsync(buff, 0, buff.Length);

task.Wait();

int readBytes = task.Result;

traceout(buff, readBytes);

}

The result of console application shows how the application is receiving the data over longer period of time:

Announcing my unplugged Session at Regional MVP CEE & Italy Summit (KulenDayz)

ddobric — Sun, 19 Aug 2012 22:55:04 GMT

At 01.09 12.30h I will give a session “Building Distributed Web Systems". Level 400.

Because the session is currently still tracked under “The Damir Dobric Session”, my intension is to share a bit more information about the content.
My intension is talk with you about hidden “power platform pieces” which already out there, no more under NDA, but still not well documented. We usually talk about terms like “mega-trends”. Today there are few of them like Massive Cloud Computing, Social Networking and Big Data. These names and trends are chosen so anybody can understand them. However such high-level tings are always based on technologies known by very small group of people called “Geeks”.

I have chosen for this session geek-technologies, which are all consisted part of Microsoft platform stack and which I will call at the day of session (at least) “power platform pieces”.

The session will focus “Building Distributed Web Systems” with addressing of important upcoming real-life scenarios. It will be shared in two subtopics:

a) Long Async Request Processing and Push-Streams in Backend
     ASP.NET 4.5 Async Handlers
     Push of data streams from Server to Client
     SignalR + WebSockets

b) Composing Hybrid Applications
    Windows Azure ServiceBus Server and Windows Azure Workflow

I would be glad to see many of you there.

IIS Service Bus Bridge

ddobric — Sat, 23 Jun 2012 09:49:26 GMT

On of upcoming interesting new features related to Service Bus is support for relaying of anything hosted in IIS. Today we are able to build SOAP and REST services which can be relayed with Service Bus. However this is limited to services only. Another option to relay the TCP traffic is “anycast” feature which is not easy to configure and it is in general not well known. Soon, it will be possible to install the IIS Service Bus bridge (see pictures below) which relays the IIS application.

This means, you can host any kind of web application (not only WCF services as now) even on your laptop and access it via publicly available URL listened at the service bus endpoint. Just imagine applications running on the private IP address and accessible publicly in internet without of doing anything on firewall and infrastructure.

More about that: http://channel9.msdn.com/Events/TechEd/NorthAmerica/2012/AZR308

University of Applied Sciences in Frankfurt: - Agenda for 18.June 2012

ddobric — Sat, 16 Jun 2012 18:04:28 GMT

DataCacheFactory dcf = new DataCacheFactory();

DataCache cache= dcf.GetCache(cCacheName);

List<DataCacheTag> tags = new List<DataCacheTag>();

            tags.Add(new DataCacheTag("key1"));
            tags.Add(new DataCacheTag("key2"));
            tags.Add(new DataCacheTag("key3"));

bool isCreated = ucdCache.CreateRegion("RegionName");

IEnumerable<KeyValuePair<string, object>> items;

items = cache.GetObjectsByTag(new DataCacheTag("nosuchtag"), "RegionName");

            items = cache.GetObjectsByTag(tags.First(), "RegionName");
            if (items.Count() > 0)
                cache.ClearRegion("RegionName");

            DataCacheItemVersion ver2 = cache.Add("Tagged", 123, tags, "Company2Customer2");

            cache.Add("Tagged1", 123, tags, "RegionName");
            cache.Put("Tagged1", 123, tags, "RegionName");
            cache.Add("Tagged2", 456, new List<DataCacheTag>() { tags.First() }, "RegionName");
            cache.Add("Tagged3", 789, new List<DataCacheTag>() { tags.Last() }, "RegionName");

cache.GetObjectsByTag(tags.First(), "RegionName").ForEach(i => Console.WriteLine(i));

NOTE: array.ForEach() is provided by daenet.system.dll. It is not contained in .NET framework!

Download Presentation: http://developers.de/media/p/317742.aspx

Next Session: https://maps.google.com/maps?q=Microsoft+Bad+Homburg,+Siemensstra%C3%9Fe,+Bad+Homburg,+Deutschland&hl=en&ie=UTF8&ll=50.216637,8.615749&spn=0.006824,0.012553&sll=49.593567,7.75526&sspn=0.884833,1.60675&oq=microsoft+bad+homburg+siemens&t=h&hq=Microsoft&hnear=Siemensstra%C3%9Fe,+Bad+Homburg+61352+Bad+Homburg,+Hessen,+Germany&z=16

Microsoft GmbH

Siemensstraße 27

61352 Bad Homburg vor der Höhe, Germany

Get directions‎

06172 661-0

Agenda for WinDays 2012: Power of SignaR and WebSockets with WCF 4.5 and Windows 8

ddobric — Tue, 17 Apr 2012 19:07:10 GMT

WHEN: 24.04.2012. 16:10 - 16:55h
WHERE: HALL 8

In this session you will learn new communication features implemented on top of WCF, ASP.NET for HTML5 and none HTML5 browsers. Come to see how WebSockets and SignalR, provided on many not only Microsoft platforms, enable amazing possibilities to build new kind of applications.
Moreover, we will talk about new duplex-based communication styles and show how to connect different kind of applications to each other in the totally connected world.
This demo powered session will give you a deeper dive in new communication technologies related products like IIS8, Windows Server 8 and Windows 8.

On WinDays Portal:: http://www.windays.hr/hr/raspored/technology/

Follow: http://twitter.com/#!/ddobric

Proxy generated by SignalR on the fly

ddobric — Sat, 17 Mar 2012 18:12:05 GMT

When the JavaScript renders script tag which includes/imports signal/rhubs the JavaScript proxy file will be generated. Commonly the JavaScript will include this virtual (none existing) script with following line:

SignalR will receive this request and will generate the proxy classe which can be used to access hubs in the MVC manner. To make this working SignalR will generate following JavaScrip proxy on the request: http://localhost/VirtualFolder/signalr/hubs

(function ($, window) {
/// <param name="$" type="jQuery" />
"use strict";

    if (typeof ($.signalR) !== "function") {
        throw "SignalR: SignalR is not loaded. Please ensure jquery.signalR.js is referenced before ~/signalr/hubs.";
    }

    var hubs = {},
        signalR = $.signalR,
        callbackId = 0,
        callbacks = {};

    // Array.prototype.map
    if (!Array.prototype.hasOwnProperty("map")) {
        Array.prototype.map = function (fun, thisp) {
            var arr = this,
                i,
                length = arr.length,
                result = [];
            for (i = 0; i < length; i += 1) {
                if (arr.hasOwnProperty(i)) {
                    result = fun.call(thisp, arr, i, arr);
                }
            }
            return result;
        };
    }

    function executeCallback(hubName, fn, args, state) {
        var hub = hubs[hubName],
            hubMethod;

if (hub) {
signalR.hub.processState(hubName, hub.obj, state);

            if (hub[fn]) {
                hubMethod = hub.obj[fn];
                if (hubMethod) {
                    hubMethod.apply(hub.obj, args);
                }
            }
        }
    }

    function updateClientMembers(instance) {
        var newHubs = {},
            obj,
            hubName = "",
            newHub,
            memberValue,
            key,
            memberKey;

for (key in instance) {
if (instance.hasOwnProperty(key)) {

obj = instance[key];

                if ($.type(obj) !== "object" ||
                        $.inArray(key, ["prototype", "constructor", "fn", "hub", "transports"]) >= 0) {
                    continue;
                }

newHub = null;
hubName = obj._.hubName;

                for (memberKey in obj) {
                    if (obj.hasOwnProperty(memberKey)) {
                        memberValue = obj[memberKey];

                        if (memberKey === "_" ||
                                $.type(memberValue) !== "function" ||
                                $.inArray(memberKey, obj._.ignoreMembers) >= 0) {
                            continue;
                        }

if (!newHub) {
newHub = { obj: obj };

newHubs[hubName] = newHub;
}

                        newHub[memberKey] = memberValue;
                    }
                }
            }
        }

        hubs = {};
        $.extend(hubs, newHubs);
    }

    function getArgValue(a) {
        return $.isFunction(a)
            ? null
            : ($.type(a) === "undefined"
                ? null
                : a);
    }

return newObj;
}

    function serverCall(hub, methodName, args) {
        var callback = args[args.length - 1], // last argument
            methodArgs = $.type(callback) === "function"
                ? args.slice(0, -1) // all but last
                : args,
            argValues = methodArgs.map(getArgValue),
            data = { hub: hub._.hubName, action: methodName, data: argValues, state: copy(hub, ["_"]), id: callbackId },
            d = $.Deferred(),
            cb = function (result) {
                signalR.hub.processState(hub._.hubName, hub, result.State);

                if (result.Error) {
                    if (result.StackTrace) {
                        signalR.hub.log(result.Error + "\n" + result.StackTrace);
                    }
                    d.rejectWith(hub, [result.Error]);
                } else {
                    if ($.type(callback) === "function") {
                        callback.call(hub, result.Result);
                    }
                    d.resolveWith(hub, [result.Result]);
                }
            };

        callbacks[callbackId.toString()] = { scope: hub, callback: cb };
        callbackId += 1;
        hub._.connection().send(window.JSON.stringify(data));
        return d;
    }

    // Create hub signalR instance
$.extend(signalR, {
        myHub: {
            _: {
                hubName: 'Daenet.SignalR.MyHub',
                ignoreMembers: ['doWork', 'namespace', 'ignoreMembers', 'callbacks'],
                connection: function () { return signalR.hub; }
            },

            doWork: function (message, callback) {
                return serverCall(this, "DoWork", $.makeArray(arguments));
            }
        }
    });

    signalR.hub = signalR("/Daenet.SignalR/signalr")
        .starting(function () {
            updateClientMembers(signalR);
        })
        .sending(function () {
            var localHubs = [];

$.each(hubs, function (key) {
var methods = [];

                $.each(this, function (key) {
                    if (key === "obj") {
                        return true;
                    }

methods.push(key);
});

localHubs.push({ name: key, methods: methods });
});

            this.data = window.JSON.stringify(localHubs);
        })
        .received(function (result) {
            var callbackId, cb;
            if (result) {
                if (!result.Id) {
                    executeCallback(result.Hub, result.Method, result.Args, result.State);
                } else {
                    callbackId = result.Id.toString();
                    cb = callbacks[callbackId];
                    if (cb) {
                        callbacks[callbackId] = null;
                        delete callbacks[callbackId];
                        cb.callback.call(cb.scope, result);
                    }
                }
            }
        });

    signalR.hub.processState = function (hubName, left, right) {
        $.extend(left, right);
    };

} (window.jQuery, window));
0

The proxy shown above has been generated for following hub class:

public class MyHub : Hub

{

public void DoWork(string message)

{

Clients.addMessage(message);

}

The JavaScript code which access the hub looks in this case like:

var myHub = $.connection.myHub;

More about hubs an GitHub: https://github.com/SignalR/SignalR/wiki/QuickStart-Hubs,
https://github.com/SignalR/SignalR/wiki/SignalR-Client-Hubs

Microsoft Network 2.0: ASP WebApi & Co.

ddobric — Tue, 13 Mar 2012 22:00:34 GMT

Announcing the session about Business and Mobile Platform evolution focused on ASP.NET WebApi and ASP.NET MVC 4.5. I’m still not sure how the final title of the session will be pronounced, but never mind. We already know what we will present.

In past decade WCF has definitely grove in the most powerful communication technology targeting SOAP as underlying protocol for message exchange. However applications are continually evolving to expose their functionality over the web. Some of them popular social services like Facebook achieve a REST as a major communication style. So we will focus now to simplification of communication stack. WCF has focused Business Platform. WEP API should focus mobile and business platforms.
This session is interesting is the story about the next step in evaluation of communication platform which allows developers to expose their applications, data and services to the web directly over HTTP.

In this session you will learn not only about ASP WebApi. Even more we will talk about SOAP and REST, SOA and Web, Applications and Apps, GET and POST and, and, and….,

You are invited to see the new API for web which is more than just REST. See also what Bahro posted about this.

Who: Bahro & Damir (Huso I Haso)
When: 04.04.2012 14.30 – 15.30h
Add to your calendar.

Session ASP WebApi

ddobric — Tue, 13 Mar 2012 21:53:13 GMT

http://msnetwork.ba/novost/9589

Emitting Empty Values with ASP.NET WebApi JSON

ddobric — Mon, 27 Feb 2012 23:09:45 GMT

Sometimes you will have complex type which have many properties. Statistically in this case some of properties in some request will not be used. If you have operations which use lists in contracts it is clear that transport of none-used values will increase the traffic on the network. To take a control of that you can use like in WCF the EmitDefaultValue attribute.

If you want to prevent rendering of default (NULL) values design the class as shown below:

[DataContract]

public class AccountData

{

/// <summary>

/// The name of the user.

/// </summary>

[DataMember(EmitDefaultValue = false)]

public string UserName { get; set; }

/// <summary>

///

/// </summary>

[DataMember(EmitDefaultValue = false)]

public List<string> Roles { get; set; }

}

Following two pictures show the result of serialization. The picture on right is serialization result in default case. If you want to optimize the traffic set the emit-attribute to FALSE (picture on left).

[DataMember(EmitDefaultValue = false)]                                               [DataMember(EmitDefaultValue = true)]
public string UserName { get; set; }                                                        public string UserName { get; set; }