.NET Tutorials, Forums, Interview Questions And Answers
Welcome :Guest
Sign In
Win Surprise Gifts!!!

Top 5 Contributors of the Month
david stephan
Gaurav Pal
Post New Web Links

Observer pattern via remoting and events

Posted By:      Posted Date: May 22, 2011    Points: 0   Category :WPF

I have a remote object, using the observer pattern, that calls a NOTIFY method on the registered client that in turn displays a message box with the message being sent by  the other clients.  All works fine.  My question is this - I would like the NOTIFY method on the registered client to trigger a client side event, instead of displaying a messge box.  However whenever I change to triggering an event within the NOTIFY method it seems to hang the entire client application. Why is this?  Any help would be appreciated. Below is a sample of the client side code called via remoting from server.

        public static GlobalEventListener<LockChangeArg> gel = GlobalEventListener<LockChangeArg>.Instance;
public void Notify(object anObject)         {   &nb

View Complete Post

More Related Resource Links

Vb.net remoting Error while registering the events on clients.?

i m getting the following error while registering the events on clients.
"An error occurred creating the form. See Exception.InnerException for details. The error is: Exception has been thrown by the target of an invocation."

'My Coding
Dim chan As HttpChannel
Dim serverProv As New BinaryServerFormatterSinkProvider
Dim clientProv As New BinaryClientFormatterSinkProvider
Dim props As IDictionary = New Hashtable
serverProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.…
props("port") = 0
'props("name") = "ChatApplication"
chan = New HttpChannel(props, clientProv, serverProv)
ChannelServices.RegisterChannel(chan, False)

theManager = CType(Activator.GetObject(Type.GetType("… "http://localhost:7777/ChatApplication")… InBetween.Manager)

AddHandler Me.theManager.evtReceiveText, Addre

Raise Events in remoting object


Hello i m new to .Net Remoting and I have following scenario and don't know how to deal with event raised on service side and handled on client side.

My remote object starts controller and controller further starts scheduler

Scheduler is responsible for scanning all jobs in queue and adding more jobs in a queue.

Queue member raises an event which i want to handle on client side

Could anyone help me to get solution for this


Remoting and events



I have a problem to solve that I am sure many others have solved before me. I would like to hear how you have solved it, and what the pros and cons are versus other alternatives.

The problem is this: An entity in a client-server application is to be modified by the server, but the client needs to take action in response to the changes. Ideally I would like the entity object to offer events that can be subscribed to whether on the server or on the client.

We are using remoting, so particulars may apply, although in general the problem of course comes from the client-server nature of the system.

I am unsure if making use of two-way remoting is the way to go. I am not (at least not yet!) talking about pushing changes from one client to another. Rather, a client provides an entity object, the server updates it, and the SAME client responds to changes in its state. It seems to me I would need some kind of "deferred" event firing mechanism, and I suppose I could implement this in my entity objects. Perhaps put event information in a queue when normally one would raise the event, so they can be raised later instead.

If anyone has any ideas or in paritcular *experience* with solutions to this problem, I'd be very interested to hear your POVs.

Dialogs and ViewModel - Using Tasks as a Pattern

The ViewModel/MVVM pattern continues to gain popularity, with a blog post showing up every so often, and with tweets and retweets popping up even more often :-). At the same time, there are some interesting topics beyond the core pattern that continue to fuel experimentation. A big one amongst those is how should applications use dialogs when using the view model pattern.

The crux of the problem is the desire to keep the view model independent of UI concerns, and ensure it can be tested in a standalone manner, but that often comes to odds when you want the view model to launch a dialog, and/or do some work after the dialog is closed.

Prototype Design Pattern in C#. Vb.NET

Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prototype

Adapter Design Pattern in C#, VB.NET

Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

Singleton Design Pattern in C#, Vb.NET

Ensure a class has only one instance and provide a global point of access to it.

The Decorator Pattern & Extension Methods

The decorator pattern provides a formal way to add new functionality to an existing type, without sub-classing. First question: What is wrong with classical inheritance? In and of itself, nothing is wrong with the good old Is-A relationship. It is very common to derive a new class from an existing base class in order to override a few virtual members, and add a pinch of new functionality.

Implementing Continuous Scrolling UI Pattern in ASP.NET

When you have numerous records to show, we have to resort to Paging. There is a better alternative to display voluminous data (especially read only data) while providing a better user experience & also making efficient use of server bandwidth - the Continuous Scrolling or Infinite Scrolling UI Pattern. Read on to know more about how to implement Continuous Scrolling UI Pattern in ASP.NET with a GridView.

WCF Tutorial - Events and Callbacks

we described how to make a very simple client/server application where clients would call functions on the server through a shared interface. In this tutorial, I'm going to expand that application to allow the server to execute functions on the client by using callbacks. Essentially, this is WCF's mechanism to allow events to be raised from the server to it's connected clients.

Factory Pattern in asp.net

The job of the Factory design pattern is to create concrete sub classes. You can see the Factory design pattern used throughout the .NET Framework.

The essence of the Factory Pattern is to "Define an interface for creating an object, but let the subclasses decide which class to instantiate. The Factory method lets a class defer instantiation to subclasses." Factory methods encapsulate the creation of objects. This can be useful if the creation process is very complex, for example if it depends on settings in configuration files or on user input.

Singleton Design Pattern in Asp.net using C#

When we want to make a only one instance of a class and also making sure that there is a global access point to that object then the design pattern we user is called Singleton. The pattern ensures that the class is instantiated only once and that all requests are directed to that one and only object.

The Factory Design Pattern

Software architects generally think in terms of high-level abstractions rather than low-level programming details. Representing a system in terms of high-level abstractions promotes understanding of the system and reduces its perceived complexity. One such set of abstractions is software design patterns. They have been successfully applied in the past to simplify and solve recurring problems in software design.

Abstract Factory Design Pattern (Sample in C# and VB .NET)

An abstract factory provides an interface for creating families of related objects without specifying their concrete classes. Sometimes one wants to construct an instance of one of a suite of classes, deciding between the classes at the time of instantiation. In order to avoid duplicating the decision making everywhere an instance is created, we need a mechanism for creating instances of related classes without necessarily knowing which will be instantiated.

Prototype Pattern-Creational Patterns in C#

The Prototype Pattern approaches the creation of the objects that our client will use by cloning instances from prototypes as required. This achieves the general aim of decoupling the client from the objects that it will use, but also adds some advantages unique to the Prototype pattern.

Abstract Factory Pattern-Creational Patterns

The Factory pattern allowed us to decouple our client from an object which it uses. The Abstract Factory pattern extends this idea to manage separate families of objects.

A runtime selection, or configuration option, in our client could decide which family of objects is to be used. The Abstract Factory pattern allows us to write generic code to instantiate and use the family objects regardless of which family is chosen at runtime. The pattern also helps us enforce a rule where objects from just the chosen family are used uniformly by the client.

Singleton Pattern-Creational Patterns

The Singleton pattern is a specialist creational pattern as it's primary focus is to facilitate a single shared instance of our object rather than to decouple our client from the object's implementation as with the other creational patterns.
ASP.NetWindows Application  .NET Framework  C#  VB.Net  ADO.Net  
Sql Server  SharePoint  Silverlight  Others  All   

Hall of Fame    Twitter   Terms of Service    Privacy Policy    Contact Us    Archives   Tell A Friend