C#

Public Property LogoutCommand As ICommand
...
LogoutCommand = New RelayCommand(AddressOf LogoutExecute, AddressOf CanLogoutExecute)

public ICommand LogoutCommand;
...
LogoutCommand = new RelayCommand(LogoutExecute, CanLogoutExecute);
...
private void LogoutExecute(){...}
private bool CanLogoutExecute()
{
 return true;
}
...

public class RelayCommand : ICommand
	{
		private readonly Action<Object> _execute;
		private readonly Predicate<Object> _canExecute;

		public RelayCommand(Action<object> execute): this(execute, null){	}

		public RelayCommand(Action<object> execute, Predicate<Object> canExecute)
		{
			if (execute == null)
			{
				throw new ArgumentException("execute");
			}
			_execute = execute;
			_canExecute = canExecute;
		}

		[DebuggerStepThrough()]
		public bool CanExecute(object parameter)
		{
			return _canExecute == null ? true : _canExecute(parameter);
		}

		public event EventHandler CanExecuteChanged
		{
			add { CommandManager.RequerySuggested += value; }
			remove { CommandManager.RequerySuggested -= value; }
		}

		public void Execute(object parameter)
		{
			_execute(parameter);
		}

	}

	public class RelayCommand<T> : ICommand
	{
		private readonly Action<T> _execute;
		private readonly Predicate<T> _canExecute;

		public RelayCommand(Action<T> execute): this(execute, null){}

		public RelayCommand(Action<T> execute, Predicate<T> canExecute)
		{
			if (execute == null)
			{
				throw new ArgumentException("execute");
			}
		}

		[DebuggerStepThrough()]
		public bool CanExecute(object parameter)
		{
			return _canExecute == null ? true : _canExecute((T)parameter);
		}

		public event EventHandler CanExecuteChanged
		{
			add { CommandManager.RequerySuggested += value; }
			remove { CommandManager.RequerySuggested -= value; }
		}

		public void Execute(object parameter)
		{
			_execute((T) parameter);
		}

	}

using (FileStream fs = File.OpenRead(path))
         {
             //HOW UTILIZE  BeginRead() IS PARAMETR
             fs.BeginRead();
         }

private void loadDataToolStripMenuItem_Click(object sender, EventArgs e)
{
     TabPage tp = new TabPage();
     tp.Text = "Data";
     System.Windows.Forms.CheckedListBox AvailableDataList = new system.Windows.Forms.CheckedListBox();
     AvailableDataList.Dock=DockStyle.Fill;
     tp.Controls.Add(AvailableDataList);

    for (bb = 0; bb < 8; bb++)
    {
        AvailableDataList.Items.Add("Bob");
        switch(SelectName(bb))
        {
            case false:
                AvailableDataList.SetItemChecked(bb, false);
                break;
            case true:
                AvailableDataList.SetItemChecked(bb, true);
        }
    tabControl1.TabPages.Add(tp);
}


private void button4_Click(object sender, EventArgs e)
{
    label1.text = AvailableDataList.Items.Count;
}

private void calculateButton_Click(object sender, EventArgs e)
       {
           int organisms;
           int days;
           int growth;
           int population;
           int count = 1;

           if (int.TryParse(OrganismsTextbox.Text, out organisms))
           {
               if (int.TryParse(DailyTextbox.Text, out growth ))

               {

                   if (int.TryParse(DaysTextbox.Text, out days))

                       do
                       {

                           population = organisms + growth * days;
                           resultsListbox.Items.Add("The population For day " + count + " is " + population.ToString("n1"));


                           count = count + 1;
                       }
                       while (count <= days);

public interface iCR
        {
            int CB_IO_Init(int slaveIndex);
            int WritePortReady();
            int WritePortBusy();
            void initCRData(byte[] writeBuffer, byte[] statusBuffer, int SlaveIndex, USB_Comm.CB cb, int cr_Type);
            int ProcessTWriting(ref Byte[] writeDat, ref Byte[] statusDat, ref Byte[] dataDumpWriteCheck);
            void Failure(String message);
            void Success(String message);

        }

namespace CR_Factory
    {

    public class Cr
    {
         
    }  

    public class CRFactory
    {
        public enum CRType
        {
            CR0,
            CR1,
            CR3,
            CR4,
            CR5,
            CR6
        }

        public CRFactory()
        {
        }

        public iCR GetCR(CRType type) 
        {
            iCR cr = null;
            switch (type)
            {
                case CRType.CR5:
                    cr = new CR5(); 
                    break;
                case CRType.CR6:
                    //not done yet
                    break;
                default:
                    throw new ArgumentException(string.Format("A CR of type {0} cannot be found", Enum.GetName(typeof(CRType), type)));
            }
            return cr;
        }

        public CRType DetermineCR_Type(int type)
        {
            switch (type)
            {
                case 0:
                    return CRType.CR0;
                //break;
                case 1:
                    return CRType.CR1;
                case 3:
                    return CRType.CR3;
                case 4:
                    return CRType.CR4;
                case 5:
                    return CRType.CR5;
                case 6:
                    return CRType.CR6;
                default:
                    throw new ArgumentException(string.Format("A type of type {0} cannot be found", type));

            }
        }

        }
    }

public class CR5 : iCR **compile error CR5_new.CR5 does not implement interface member iCR.initCRData(byte[],byte[],int,USB_Comm.CB,int)
    {        
        CB_703 cb_specific = null;
		
        //constructor
        public CR5()
        {
            cb_specific = new CB_703(SlaveIndex);
        }

        public void initCRData(byte[] writeBuffer, byte[] statusBuffer, int slaveIndex, USB_Comm.CB cb_specificInstance, int crType)
        {...
        }

        public int CB_IO_Init(int SlaveIndex)
        {
            int result = -534;
            result = cb_specific.IO_Init(SlaveIndex);
            return result;
        }
    .
    .
    .
    }

namespace CrWr
    {
    
    public partial class PControl : UserControl
    {
        //setup 
	
        //constructor
        public PControl()
        {
            
        }

        /// <summary>
        /// Get the P Control for chosen dll
        /// </summary>
        public Control GetPControl(USB_Comm.CB cbInstance, string dllSelected, THandlerApplication.Temp.TEMP[] temp, string dll, SC.SC.S_C c0)
        {
            cb = cbInstance;
            createControls();
            itsDll = dll;
            tArr = temp;
            cert = c0;
      
            CR_Factory.CRFactory factory = new CR_Factory.CRFactory();
            CRFactory.CRType type = factory.DetermineCR_Type(cr_Type);
            try
            {
                cr = factory.GetCR(type);             }
            catch (Exception ex)
            {
                Console.WriteLine(ex.InnerException);
            }
            return this;
        }

    private void OnP()
        {
            int result = -536;
            
            while (rL)
            {
                result = cr.CB_IO_Init(SlaveIndex); 
                if (result == 0)
                {
                    …
                }
            }

    .
    .
    .
    }