WPF Features NOT in Silverlight Beta 4.0 and other restrictions

1. Simple Inline XAML

2. Silverlight does not support dynamic resources
Only static resources

3. No XPath binding

4. Triggers
workaround
Expression.Samples.Interactivity
System.Windows.Interactivity

Download the example here

5. Silverlight compiled DLL's can only be reference to your Silvelight project.

6. DocumentViewer Control

7. Adorner

8. MultiBindings

9. Updatetrigger

10. Cannot read and write to your local disk
Example:
HtmlPage.Window.Navigate(new Uri("C:\\Users\\userName\\Downloads\\test.pdf"), "_blank");
HtmlPage.Window.Navigate(new Uri("C:\\Users\\userName\\AppData\\LocalLow\\Microsoft\\Silverlight\\is\\t1frcinf.y5b\\adbxgs00.suq\\1\\s\\i4j5zwj5lwo3dexs43ahtvmg2bjlsx11spczjmw5ud3c3dignoaaahea\\f\\MHVStore\\WhatsNewInSilverlight4.pdf"), "_blank");


*** You can access the absolutepath of your IsolatedStorage but it is not the best practice.

10. Refection

C# How to open a file

Syntax for opening a file is:

System.Diagnostics.Process.Start("FileNameHere");

However this is not permitted in Silverlight 4.0

Silverlight 4.0 and Visual Studio 2010 Released Candidate

Only Silverlight 3 projects are supported with the Visual Studio 2010 Release Candidate build – however Silverlight 4 projects are not yet supported.
If you are doing Silverlight 4.0 development, it is recommended to stay in Visual Studio 2010 Beta 2 build for now.

For more info you can check the links below:
Quick FAQ on Visual Studio 2010 RC …
VS2010 RC and SL4

Overview of Implementation of Peer-to-Peer in C#

Peer-to-Peer(P2P) architecture is a serverless architecture. In a peer mesh network, in order for them to be considered and classified as peer, first, the node needs to be included in a peer mesh layer. To do so, their are two options. First by using PNRP(Peer Name Resolution Protocol) and Custom Peer Resolver.

Managed Extensibility Framework(MEF)

MEF is the creation of extensible applications. It offers discovery and composition capabilities that you can leverage to load application extensions (.dll's).
It provides a standard way for the host application to expose itself and consume external extensions; sets of discovery approaches for your application to locate and load available extensions; and tagging extensions with additonal metadata which facilitates querying and filtering.

Eventing in MVVM pattern without using Caliburn Framework

Steps:

1. You need to have an EventBehaviourFactory class. You can copy this code.

public static class EventBehaviourFactory
{
public static DependencyProperty CreateCommandExecutionEventBehaviour(RoutedEvent routedEvent, string propertyName, Type ownerType)
{
DependencyProperty property = DependencyProperty.RegisterAttached(propertyName, typeof(ICommand), ownerType,
new PropertyMetadata(null,
new ExecuteCommandOnRoutedEventBehaviour(routedEvent).PropertyChangedHandler));

return property;
}

///

/// An internal class to handle listening for an event and executing a command,
/// when a Command is assigned to a particular DependencyProperty
///

private class ExecuteCommandOnRoutedEventBehaviour : ExecuteCommandBehaviour
{
private readonly RoutedEvent _routedEvent;

public ExecuteCommandOnRoutedEventBehaviour(RoutedEvent routedEvent)
{
_routedEvent = routedEvent;
}

///

/// Handles attaching or Detaching Event handlers when a Command is assigned or unassigned
///

///
///
///
protected override void AdjustEventHandlers(DependencyObject sender, object oldValue, object newValue)
{
UIElement element = sender as UIElement;
if (element == null) { return; }

if (oldValue != null)
{
element.RemoveHandler(_routedEvent, new RoutedEventHandler(EventHandler));
}

if (newValue != null)
{
element.AddHandler(_routedEvent, new RoutedEventHandler(EventHandler));
}
}

protected void EventHandler(object sender, RoutedEventArgs e)
{
HandleEvent(sender, e);
}
}

internal abstract class ExecuteCommandBehaviour
{
protected DependencyProperty _property;
protected abstract void AdjustEventHandlers(DependencyObject sender, object oldValue, object newValue);

protected void HandleEvent(object sender, EventArgs e)
{
DependencyObject dp = sender as DependencyObject;
if (dp == null)
{
return;
}

ICommand command = dp.GetValue(_property) as ICommand;

if (command == null)
{
return;
}

if (command.CanExecute(e))
{
command.Execute(e);
}
}

///

/// Listens for a change in the DependencyProperty that we are assigned to, and
/// adjusts the EventHandlers accordingly
///

///
///
public void PropertyChangedHandler(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
// the first time the property changes,
// make a note of which property we are supposed
// to be watching
if (_property == null)
{
_property = e.Property;
}

object oldValue = e.OldValue;
object newValue = e.NewValue;

AdjustEventHandlers(sender, oldValue, newValue);
}
}
}

2. Create a relay command class which inherits ICommand Interface. You can copy this code. An ICommand contains methods to execute commands. A command can be executed many times, and the parameter values can vary. This interface is mandatory on commands.

Namespace: System.Windows.Input
Assembly: PresentationCore (in PresentationCore.dll)

public class RelayCommand:ICommand
{
#region private fields
readonly Action