Design Pattern

Creational
Behavioral
Structural

C# Serialization and Deserialization

As we know you make an object serializable by either implementing the ISerializable interface or by placing the [Serializable] at the top of the class.


1. Students Class


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace SysDiagnosis
{
    public class Student
    {
        public string Name { get; set; }
        public string ID { get; set; }
        public int Age { get; set; }
        public string Gender { get; set; }
        public double Grade { get; set;}        
    }
}





2. SerilizeHelper Class



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.IO;

namespace SysDiagnosis
{
    public  class SerializeHelper
    {
        public static void SerializeMe(object obj, string strPath)
        {
            XmlSerializer serilizser = new XmlSerializer(obj.GetType());
            StreamWriter writter = new StreamWriter(strPath);
            serilizser.Serialize(writter.BaseStream,obj);
        }
    }
}


3. Main Program


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Management;

namespace SysDiagnosis
{
    class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student();
            student.Name = "Vinodh";
            student.ID = "EE01";
            student.Age = 27;
            student.Gender = "Male";
            student.Grade = 7.50;
            Console.WriteLine("Serializing object to XML");
            SerializeHelper.SerializeMe(student,@"C:\students.xml");
            Console.ReadLine();                          
        }
    }
}


4.Ouput File : (c:\students.xml)


<?xml version="1.0"?>
<Student xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>Vinodh</Name>
  <ID>EE01</ID>
  <Age>27</Age>
  <Gender>Male</Gender>
  <Grade>7.5</Grade>
</Student>




 class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student();
            student.Name = "Vinodh";
            student.ID = "EE01";
            student.Age = 27;
            student.Gender = "Male";
            student.Grade = 7.50;
            Console.WriteLine("Serializing Object to XML");
            SerializeHelper.SerializeMe(student, @"C:\students.xml");
            Console.WriteLine("Serializing XML to Object");
            SerializeHelper.SerializeMe(@"C:\students.xml", new Student());
       }
 }






namespace SysDiagnosis
{
    public  class SerializeHelper
    {
        public static void SerializeMe(object obj, string strPath)
        {
            XmlSerializer serilizser = new XmlSerializer(obj.GetType());
            StreamWriter writter = new StreamWriter(strPath);
            serilizser.Serialize(writter.BaseStream,obj);
            writter.Close();
        }

        public static void SerializeMe(string strPath, Student obj)
        {
            XmlSerializer serilizer = new XmlSerializer(obj.GetType());
            StreamReader reader = new StreamReader(strPath);
            object deserialize = serilizer.Deserialize(reader.BaseStream);
            obj = deserialize as Student;

            Console.WriteLine(obj.Name);
            Console.WriteLine(obj.ID);
            Console.WriteLine(obj.Age);
            Console.WriteLine(obj.Gender);                  
            Console.WriteLine(obj.Grade);


        }
    }
}


Serializatiion :

https://www.codeproject.com/Articles/1789/Object-Serialization-using-C
http://www.c-sharpcorner.com/uploadfile/yougerthen/how-to-serialize-an-object-using-an-iserializable-interface/

Model,View and View Model Patern (M V VM pattern)

The MVVM Pattern

The Model-View-ViewModel pattern can be used on all XAML platforms. Its intent is to provide a clean separation of concerns between the user interface controls and their logic.
There are three core components in the MVVM pattern: the model, the view, and the view model. Each serves a distinct and separate role. The following illustration shows the relationships between the three components.

The components are decoupled from each other, thus enabling:

• Components to be swapped
• Internal implementation to be changed without affecting the others
• Components to be worked on independently
• Isolated unit testing

In addition to understanding the responsibilities of the three components, it's also important to understand how the components interact with each other. At the highest level, the view "knows about" the view model, and the view model "knows about" the model, but the model is unaware of the view model, and the view model is unaware of the view.

The view model isolates the view from the model classes and allows the model to evolve independently of the view.

View

The view is responsible for defining the structure, layout, and appearance of what the user sees on the screen. Ideally, the view is defined purely with XAML, with a limited code-behind that does not contain business logic.
In a Windows Phone application, a view is typically a page in the application. In addition, a view could be a sub-component of a parent view, or a DataTemplate for an object in an ItemsControl.
A view can have its own view model, or it can inherit its parent's view model. A view gets data from its view model through bindings, or invoking methods on the view model. At run time, the view changes when UI controls respond to view model properties raising change notification events.
There are several options for executing code on the view model in response to interactions on the view, such as a button click or item selection. If the control is a Command Source, the control’s Command property can be data-bound to an ICommand property on the view model. When the control’s command is invoked, the code in the view model will be executed. In addition to commands, behaviors can be attached to an object in the view and can listen for either a command to be invoked or event to be raised. In response, the behavior can then invoke an ICommand on the view model or a method on the view model.

Model

The model in MVVM is an implementation of the application's domain model that includes a data model along with business and validation logic. Examples of model objects include repositories, business objects, data transfer objects (DTOs), Plain Old CLR Objects (POCOs), and generated entity and proxy objects.

View Model

The view model acts as an intermediary between the view and the model, and is responsible for handling the view logic. Typically, the view model interacts with the model by invoking methods in the model classes. The view model then provides data from the model in a form that the view can easily use. The view model retrieves data from the model and then makes the data available to the view, and may reformat the data in some way that makes it simpler for the view to handle. The view model also provides implementations of commands that a user of the application initiates in the view. For example, when a user clicks a button in the UI, that action can trigger a command in the view model. The view model may also be responsible for defining logical state changes that affect some aspect of the display in the view, such as an indication that some operation is pending.
In order for the view model to participate in two-way data binding with the view, its properties must raise the PropertyChanged event.
View models satisfy this requirement by implementing the INotifyPropertyChanged interface and raising the PropertyChanged event when a property is changed. Listeners can respond appropriately to the property changes when they occur.
For collections, the view-friendly System.Collections.ObjectModel.ObservableCollection<T> is provided. This collection implements collection changed notification, relieving the developer from having to implement the INotifyCollectionChanged interface on collections.

Connecting View Models to Views

MVVM leverages the data-binding capabilities in Silverlight to manage the link between the view and view model, along with behaviors and event triggers. These capabilities limit the need to place business logic in the view's code-behind.
There are many approaches to connecting a view model to a view, including direct relations and container-based approaches. However, all share the same aim, which is for the view to have a view model assigned to its DataContext property.
Views can be connected to view models in a code-behind file, or in the view itself.

Code-Behind

A view can have code in the code-behind file that results in the view model being assigned as its DataContext property. This could be as simple as a view instantiating a new view model and assigning it to its DataContext, or injecting a view model into a view using an inversion-of-control container.
However, connecting a view model to a view in a code-behind file is discouraged as it can cause problems for designers in both Visual Studio and Microsoft Expression Blend® design software.

View

If a view model does not have any constructor arguments, the view model can be instantiated in the view as the view’s DataContext. A common approach to doing this is to use a view model locator. This is a resource which exposes the application’s view models as properties that individual views can data bind to. This approach means that the application has a single class that is responsible for connecting view models to views. In addition, it still leaves developers free to choose to manually perform the connection within the view model locator, or by using a dependency injection container.

The Benefits of MVVM

MVVM enables a great developer-designer workflow, providing these benefits:

• During the development process, developers and designers can work more independently and concurrently on their components. The designers can concentrate on the view, and if they are using Expression Blend, they can easily generate sample data to work with, while the developers can work on the view model and model components.
• The developers can create unit tests for the view model and the model without using the view. The unit tests for the view model can exercise exactly the same functionality as used by the view.
• It is easy to redesign the UI of the application without touching the code because the view is implemented entirely in XAML. A new version of the view should work with the existing view model.
• If there is an existing implementation of the model that encapsulates existing business logic, it may be difficult or risky to change. In this scenario, the view model acts as an adapter for the model classes and enables you to avoid making any major changes to the model code.

For more information about MVVM, see these chapters in the Prism documentation: Chapter 5, Implementing the MVVM Pattern and Chapter 6, Advanced MVVM Scenarios.




read more : http://msdn.microsoft.com/en-us/library/hh848246.aspx

Semantic Web in plain english

The semantic web is about making computers behave (or ‘think’) more like humans. The easiest way to understand what this means is to use a cooking analogy. Think of each website where you put your content as a big cookpot. You might throw a carrot into one pot and tag it ‘carrot’, and into another you might put some spaghetti and tag it ‘pasta’. Computers are fine with this kind of input.

But what computers can’t do yet is understand that the thing you called ‘carrot’ is a root vegetable, is full of Vitamin A – and that you are making minestrone soup. It also doesn’t know that you have another pot simmering, and that there’s pasta in there. Or that you need to make a sauce for it. This kind of thinking requires context, and an ability to see the big picture – that is, to know what’s in each pot, and to understand that you’re making dinner. That’s all that data-meshing is; it’s about applying meaning to information from different sources. This is what the semantic web is all about; I call it the “web of meaning” or the “contextual web”. It means being able to ask your computer everything from “When did I last have Sally over?” to “Can I afford a new laptop this month?”.

read more

cannot be opened because its project type (.csproj) is not supported by this version of the application.

Go to Start> All Programs > Visual Studio 2008 > Visual Studio Tools > Click Visual Studio 2008 Command Prompt. Type the below command and press enter.

devenv.exe /resetskippkgs

SQL Delete current database

I need to delete my current database which I am using it , I googled around and found this answer:

http://sqlserver2000.databases.aspfaq.com/how-do-i-drop-a-sql-server-database.html

ALTER DATABASE myDataBase
    SET SINGLE_USER
    WITH ROLLBACK IMMEDIATE

DELETE DATABASE myDataBase 

Password protect your outlook

This link guides you, how to protect your Outlook with password :

http://www.groovypost.com/howto/password-protect-outlook-pst-file/ 

Biztalk System.Exception assembly location

C# difference between StringBuilder and String Object

The most common operation with string is concatenation, and this has to be performed very efficiently.
When we use String objects to concatenate two strings , then a new copy of string object is created in memory by adding two objects , and the old string object is deleted.

So we use StringBuilder to do it in a effective way, here the concatenation is done on the exsisting  string, hence the insertion is faster. Concatenation is done using Append() method

C# difference between XmlDocument.Load() and XmlDocument.LoadXml()

XmlDocument.Load() is used to load a stream, or from xml file path.
XmlDodument.LoadXml() literally loads content of xml.

C# convert document to string type.

Hi Guys,
There was a situation in my project where I have to convert a xml document to string type, initially I though it is very difficult, and later I felt  it is a cake-walk actually!, the below code snippet shows how to achieve it:

• First you create a XmlDocument object, then you load the content of the xml document file into the object , where 'file' is the path of the xml file.
• Create a stringwriter , and save the contnet of xmldocument object into the string writer 'sw'
• Convert the string writer 'sw' to string and store it in a string variable.

C# Shallow Copy and Deep Copy

http://www.codeproject.com/Articles/28952/Shallow-Copy-vs-Deep-Copy-in-NET 

Difference between null and String.Empty

1. string statement=null : means no object exists; null is not a value, it is a state indicating that object value is unknown or does not exists.

2. string statement = String.Empty : use of string.Empty doesn't create any objects  while "" creates a string object. So using string.Empty is better than using "" because every time you use "", it creates a new string while string.Empty just reference s string in memory that is created by default.

Understanding Reflection and static constructor

Hi .net newbies,
This post is mostly for you !!, to understand what  Reflection and static constructor really mean ,and when are they used in  .net projects.

You would have learnt what does .net reflection and static constructor mean , 

You may say reflection is :  The process of obtaining information about the assemblies and the types defined within them ,and creating and invoking and accessing type instance at run time and

You may say static constructor is used to initialize any static data or to perform a certain action that needs to be performed once.

So when do you use Reflection or static constructor, the below picture answers the question:

WCF as Windows Services Step by Step example

Hi Guys, in this post I will be explaining how to create a simple WCF service and host it as a 'Windows Service'.

Lets create a simple Windows Service which has a OperationContract which will add numbers and return it

Step 1: Create a simple WCF service library
Step 2: Create a simple Windows Services in which you will host the service
Step 3: Install the Windows Service
Step 4: Consume the Windows Services in a Windows Form Client.

Step 1: Create simple WCF Service library:

1. Open Visual Studio 2010 , Create new project and choose Windows Service Library named as Wcf_WindowsService_Add

2. Delete these files: App.config, IService1.cs, Service1.cs, and create your own WCF Service, Right click your project and create new item - > WCF Service name it as WindowsServiceAdd.cs

                             

3. In app.config files you can see two endpoints with bindings wsHttpBinding and mexHttpBinding and with abase address

4. Open  IWindowsServiceAdd.cs  Interface remove Dowork() Contract and your Contract with name Add()

5.  Open  WindowsServiceAdd.cs  remove DoWork() and define your Add() OperationContract :

6. Build your project , now your WCF Service library dll is ready to use.


Step 2: Create a simple Windows Services in which you will host the service:




1. Right Click your solution and create new project. -> Windows -> Windows Services.

                              

2. Delete Program.cs and Service1.cs and create your own Service , by right clicking the project add new item -> Windows Service

                          

3. Click 'click here to switch to code view' , and modify the code as shown below to add a Service Host and methods to stop and start the services ,and add System.ServiceModel to your project , and your Service Library dll too

4. Add Program.cs file

5.Build this project . now it is ready to be installed in your machine

Step 3: Install the Windows Service 


1. Inorder to install the service we need Installer class, so add new installer class:

2.Goto Start - > All programs -> Visual Studio 2010 - > Visual Studio Tools -> Visual Studio command prompt. Goto to  path of your serviceAdd.exe ,  and install it using ' installutil serviceAdd.exe

3. You can see your service in Service Console

Step 4: Consume the Windows Services in a Windows Form Client.


1. Start your service , Create a new Windows Form project, refer your WCF hosted as Windows services ( http://localhost:8732/Design_Time_Addresses/Wcf_WindowsService_Add/WindowsServiceAdd/ ) to this project. add a  lable and a button, double click the button and and add the bellow code , and run your project :

2. Build and Run your Windows Form to consume the service

Orchestration Dehydration & Rehydration

When many long-running business processes are running at the same time, memory and performance are potential issues. The orchestration engine addresses these issues by "dehydrating" and "rehydrating" orchestration instances.

Dehydration is the process of serializing the state of an orchestration into a SQL Server database. Rehydration is the reverse of this process: deserializing the last running state of an orchestration from the database. Dehydration is used to minimize the use of system resources by reducing the number of orchestrations that have to be instantiated in memory at one time.

The orchestration engine might determine that an orchestration instance has been idle for a relatively long period of time. It calculates thresholds to determine how long it will wait for various actions to take place, and if those thresholds are exceeded, it dehydrates the instance. This can occur under the following circumstances:

• When the orchestration is waiting to receive a message, and the wait is longer than a threshold determined by the engine.
• When the orchestration is "listening" for a message, as it does when you use a Listen shape, and no branch is triggered before a threshold determined by the engine. The only exception to this is when the Listen shape contains an activation receive.
• When a delay in the orchestration is longer than a threshold determined by the engine.

The engine dehydrates the instance by saving the state, and frees up the memory required by the instance. By dehydrating dormant orchestration instances, the engine makes it possible for a large number of long-running business processes to run concurrently on the same computer.

You can set 12 properties to configure how dehydration works in BizTalk Server. The topics in this section list and describe these properties and their default values, and discuss how various values affect dehydration behavior.

The orchestration engine can be triggered to rehydrate an orchestration instance by the receipt of a message or by the expiration of a time-out specified in a Delay shape. It then loads the saved orchestration instance into memory, restores its state, and runs it from the point where it left off. For more information about using shapes in orchestrations, see Orchestration Shapes.

An orchestration can be configured to run on more than one server. After an orchestration instance has been dehydrated, it can be rehydrated on any of these servers. If one server goes down, the engine continues to run the orchestration on a different server, continuing from its previous state. The engine also takes advantage of this feature to implement load balancing across servers.

Biztalk : Moving simple file from one folder to another folder

We can easily move files from one folder to another destination folder using Biztalk Server Administrator console. You need to use the filters to achieve this.

read more :  http://bryantlikes.com/pages/463.aspx 

SQL Constraints

Constraints limit the type of  data that can go into the table.
The following are the constraints:

1. NOT NULL
2. UNIQUE
3. PRIMARY KEY
4. FOREIGN KEY
5. CHECK
6. DEFAULT

SQL Joins

Hi newbies,
Want to learn SQL joins at a glance!!, here you go... SQL joins is Venn diagram representation:
A very nice picture given in codeproject.

http://www.codeproject.com/Articles/33052/Visual-Representation-of-SQL-Joins

What are EXD files

EXD is control information cache file . It is a type of file that contains your most recently used information of a computer object , which in this case is a control

read more