C#

Dictionary<int, Customer> customers = new Dictionary<int, Customer>();
Customer cust1 = new Customer();
 customers.Add(cust1.ID, cust1);
 customers.Add(cust2.ID, cust1);
 customers.Add(cust3.ID, cust1);

#region Instance Fields

 private string strOrigin = "";
 //the chat member name
 private string m_Member;
 //the channel instance where we execute our service methods against
 private IServerChannel m_participant;
 //the instance context which in this case is our window since it is the service host
 private InstanceContext m_site;
 //our binding transport for the p2p mesh
 private NetPeerTcpBinding m_binding;
 //the factory to create our chat channel
 private ChannelFactory<IServerChannel> m_channelFactory;
 //an interface provided by the channel exposing events to indicate
 //when we have connected or disconnected from the mesh
 private IOnlineStatus o_statusHandler;
 //a generic delegate to execute a thread against that accepts no args
 private delegate void NoArgDelegate();
 //an object to hold user details
 private IUserService userService;
 //an Observable Collection of object to get all the Application Instance Details in databas
 ObservableCollection<AppLoginInstance> appLoginInstances;
 // an Observable Collection of object to get all Incoming Messages types
 ObservableCollection<MessageType> inComingMessageTypes;
 // an Observable Collection of object to get all Outgoing Messages
 ObservableCollection<PDCL.ERP.DataModels.Message> outGoingMessages;
 // an Observable Collection of object to get all Incoming Messages
 ObservableCollection<PDCL.ERP.DataModels.Message> inComingMessages;
 //an Event Aggregator to publish event for other modules to subscribe
 private readonly IEventAggregator eventAggregator;

 /// <summary>
 /// an IUnityCOntainer to get the container
 /// </summary>
 private IUnityContainer container;
 private RefreshConnectionStatus refreshConnectionStatus;
 private RefreshConnectionStatusEventArgs args;
 private ReplyRequestMessage replyMessageRequest;
 private ReplyRequestMessageEventArgs eventsArgs;

 #endregion

 public P2pMessageService(IUserService UserService, IEventAggregator EventAggregator, IUnityContainer container)
 {
     userService = UserService;
     this.container = container;
     appLoginInstances = new ObservableCollection<AppLoginInstance>();
     inComingMessageTypes = new ObservableCollection<MessageType>();
     inComingMessages = new ObservableCollection<PDCL.ERP.DataModels.Message>();
     outGoingMessages = new ObservableCollection<PDCL.ERP.DataModels.Message>();
     this.args = new RefreshConnectionStatusEventArgs();
     this.eventsArgs = new ReplyRequestMessageEventArgs();
     this.eventAggregator = EventAggregator;
     this.refreshConnectionStatus = this.eventAggregator.GetEvent<RefreshConnectionStatus>();
     this.replyMessageRequest = this.eventAggregator.GetEvent<ReplyRequestMessage>();
 }


 #region IOnlineStatus Event Handlers
 void ostat_Offline(object sender, EventArgs e)
 {
     // we could update a status bar or animate an icon to
     //indicate to the user they have disconnected from the mesh

     //currently i don't have a "disconnect" button but adding it
     //should be trivial if you understand the rest of this code
 }

 void ostat_Online(object sender, EventArgs e)
 {
     try
     {
         m_participant.Join(userService.AppInstance);
     }
     catch (Exception Ex)
     {
         Logger.Exception(Ex, Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
     }
 }

 #endregion

 #region IServer Members

 //this method gets called from a background thread to
 //connect the service client to the p2p mesh specified
 //by the binding info in the app.config
 public void ConnectToMesh()
 {
     try
     {

         m_site = new InstanceContext(this);

         //use the binding from the app.config with default settings
         m_binding = new NetPeerTcpBinding("P2PMessageBinding");

         m_channelFactory = new DuplexChannelFactory<IServerChannel>(m_site, "P2PMessageEndPoint");
         m_participant = m_channelFactory.CreateChannel();
         o_statusHandler = m_participant.GetProperty<IOnlineStatus>();
         o_statusHandler.Online += new EventHandler(ostat_Online);
         o_statusHandler.Offline += new EventHandler(ostat_Offline);
         //m_participant.InitializeMesh();
         //this.appLoginInstances.Add(this.userService.AppInstance);

         BackgroundWorkerHelper.DoWork<object>(() =>
         {
             //this is an empty unhandled method on the service interface.
             //why? because for some reason p2p clients don't try to connect to the mesh
             //until the first service method call.  so to facilitate connecting i call this method
             //to get the ball rolling.
             m_participant.InitializeMesh();
             //SynchronizeMessage(this.inComingMessages);
             return new object();
         }, arg =>
         {

         });

         this.appLoginInstances.Add(this.userService.AppInstance);

     }
     catch (Exception Ex)
     {
         Logger.Exception(Ex, Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
     }
 }


 public void Join(AppLoginInstance obj)
 {
     try
     {
         // Adding Instance to the PeerList

         if (appLoginInstances.SingleOrDefault(a => a.InstanceId == obj.InstanceId)==null)
         {
             appLoginInstances.Add(obj);
             this.refreshConnectionStatus.Publish(new RefreshConnectionStatusEventArgs() { Status = m_channelFactory.State });
         }

         //this will retrieve any new members that have joined before the current user
         m_participant.SynchronizeMemberList(userService.AppInstance);

     }
     catch(Exception Ex)
     {
         Logger.Exception(Ex,Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
     }
 }

 /// <summary>
 /// Synchronizes member list
 /// </summary>
 /// <param name="obj">The AppLoginInstance Param</param>
 public void SynchronizeMemberList(AppLoginInstance obj)
 {

     //as member names come in we simply disregard duplicates and
     //add them to the member list, this way we can retrieve a list
     //of members already in the chatroom when we enter at any time.

     //again, since this is just an example this is the simplified
     //way to do things.  the correct way would be to retrieve a list
     //of peernames and retrieve the metadata from each one which would
     //tell us what the member name is and add it.  we would want to check
     //this list when we join the mesh to make sure our member name doesn't
     //conflict with someone else
     try
     {
         if (appLoginInstances.SingleOrDefault(a => a.InstanceId == obj.InstanceId) == null)
         {
             appLoginInstances.Add(obj);
         }
     }
     catch (Exception Ex)
     {
         Logger.Exception(Ex, Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
     }
 }

 /// <summary>
 /// This methos broadcasts the mesasge to all peers.
 /// </summary>
 /// <param name="msg">The whole message which is to be broadcasted</param>
 /// <param name="securityLevels"> Level of security</param>
 public void BroadCastMsg(PDCL.ERP.DataModels.Message msg, List<string> securityLevels)
 {
     try
     {
         foreach (string s in securityLevels)
         {
             if (this.userService.IsInRole(s))
             {
                 if (this.inComingMessages.Count == 0 && msg.CreatedByApp != this.userService.AppInstanceId)
                 {
                     this.inComingMessages.Add(msg);
                 }
                 else if (this.inComingMessages.SingleOrDefault(a => a.MessageId == msg.MessageId) == null && msg.CreatedByApp != this.userService.AppInstanceId)
                 {
                     this.inComingMessages.Add(msg);
                 }
             }
         }
     }
     catch (Exception Ex)
     {
         Logger.Exception(Ex, Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
     }

 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="msg">The Message to denyed</param>
 public void BroadCastReplyMsg(PDCL.ERP.DataModels.Message msg)
 {
     try
     {
         //if (this.inComingMessages.SingleOrDefault(a => a.MessageId == msg.MessageId) != null)
         //{
             this.replyMessageRequest.Publish(new ReplyRequestMessageEventArgs() { Message = msg });
             this.inComingMessages.Remove(this.inComingMessages.SingleOrDefault(o => o.MessageId == msg.MessageId));
         //}

     }
     catch (Exception ex)
     {
         Logger.Exception(ex, ex.TargetSite.Name + ": " + ex.TargetSite + ": " + ex.Message);
     }
 }

 //again we need to sync the worker thread with the UI thread via Dispatcher
 public void Whisper(string Member, string MemberTo, string Message)
 {


 }

 public void InitializeMesh()
 {
     //do nothing
 }

 public void Leave(AppLoginInstance obj)
 {
     if (this.appLoginInstances.SingleOrDefault(a => a.InstanceId == obj.InstanceId) != null)
     {
         this.appLoginInstances.Remove(this.appLoginInstances.Single(a => a.InstanceId == obj.InstanceId));
     }
 }

 //public void SynchronizeRemoveMemberList(AppLoginInstance obj)
 //{
 //    if (appLoginInstances.SingleOrDefault(a => a.InstanceId == obj.InstanceId) != null)
 //    {
 //        appLoginInstances.Remove(obj);
 //    }
 //}

 #endregion

ListBox1.DataSource = payItemClass.GetPayItems();
ListBox1.DisplayMember = "PayItem.Code";
ListBox1.ValueMember = "PayItem.Id";

private void CheckExcelfile()
       {
           string path = @"C:\Servicedeatils.xls";
           if (!File.Exists(path))
           {
               using (StreamWriter sw = File.CreateText(path))
               {
               How to add columns to the created excel file??

               }
           }


       }

public class Student : INotifyPropertyChanged
   {       
           const int MINIMUM_AGE = 1;
           int rollNumber = 0;
           int age = 0;
           string studentName = string.Empty;
    
           #region INotifyPropertyChanged Members
           public event PropertyChangedEventHandler PropertyChanged;
           #endregion
    
           public Student() { }
           public Student(string studentName, int age, int rollNumber)
           {           
               this.StudentName = studentName;
               this.StudentAge = age;
               this.RollNumber = rollNumber;
           }
    
           public string Name
           {
               get
               {
                   return this.studentName;
               }
               set
               {
                   if (value != this.studentName)//guard clause
                   {
                       if (value.Trim() == string.Empty)
                           throw new Exception("Name assigned does not confirms to the format. Please assign a proper alphanumeric value.");
                       this.studentName = value;
                       this.DisplayPropertyChange("StudentName");
                   }
               }
           }
    
           public int StudentAge
           {
               get
               {
                   return this.age;
               }
               set
               {
                   if (value != this.age)//guard clause
                   {
                       //any value lesss than minumum age goes to minimum ages.
                       if (value < MINIMUM_AGE)
                           this.age = MINIMUM_AGE;                                   
                       else
                           this.age = value;
                        this.DisplayPropertyChange("StudentAge");
                   }
               }
           }
    
           public int RollNumber
           {
               get
               {
                   return this.rollNumber;
               }
               set
               {
                   if (value != this.rollNumber)//guard clause
                   {
                       if (value < 0)
                           throw new Exception("Wrong value supplied. Only non negative integers allowed.");
                       this.rollNumber = value;
                       this.DisplayPropertyChange("RollNumber");
    
                   }
               }
           }
    
           void DisplayPropertyChange(string propertyName)
           {
               if (null!=this.PropertyChanged)
               {
                   this.PropertyChanged(this,new PropertyChangedEventArgs(propertyName));
               }
           }        
   }

public class StudentName
 {
       string firstName = string.Empty;
       string lastName = string.Empty;

       public string FirstName
       {
           get { return firstName; }
           set { firstName = value; }
       }
       public string LastName
       {
           get { return lastName; }
           set { lastName = value; }
       }

       public string FullName
       {
           get { return String.Concat(this.firstName," ",this.lastName); }
       }
       //Default
       public StudentName()
       {}
       //Overloaded
       public StudentName(string firstName, string lastName)
       {
           this.firstName = firstName;
           this.lastName = lastName;
       }
}

Student student=new Student();
  string.Format("The student's name is {0}",student.Name.FullName);