Академический Документы
Профессиональный Документы
Культура Документы
Xml System.Xml.Linq
create a libraryclass named SearchEngineLib. References: Microsoft.CSharp System System.Core System.Data System.Data.DataSetExtensions System.Xml System.Xml.Linq Roots(folder): AbstractRootFinder.cs ActiveRootFinder.cs InvalidRootDescriptionException.cs IRootFinder.cs RootFinderEnum (others->codefile) RootFinderFactory.cs
namespace SearchEngineLib.Roots { public abstract class AbstractRootFinder : IRootFinder { protected List<String> listOfRoots;
ActiveRootFInder.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO;
namespace SearchEngineLib.Roots { public class ActiveRootFinder:AbstractRootFinder { public override List<String> GetRoots() { DriveInfo[] activeDrive = DriveInfo.GetDrives(); foreach (DriveInfo drive in activeDrive) { if (drive.IsReady) listOfRoots.Add(drive.Name); }
return listOfRoots;
} } }
InvalidRootDescriptionException.cs: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO;
namespace SearchEngineLib.Roots { public class ActiveRootFinder:AbstractRootFinder { public override List<String> GetRoots() { DriveInfo[] activeDrive = DriveInfo.GetDrives(); foreach (DriveInfo drive in activeDrive) { if (drive.IsReady) listOfRoots.Add(drive.Name); }
return listOfRoots; } } }
namespace SearchEngineLib.Roots { public interface IRootFinder { List<String> GetRoots();//returns list of drives int GetNumberofRoots();//returns number of drives } }
}; }
folder = new SystemRootFinder(); else throw new InvalidRootDescriptionException("Invalid Roots"); return folder; } } }
SystemRootFinder.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO;
namespace SearchEngineLib.Roots { public class SystemRootFinder:AbstractRootFinder { public override List<String> GetRoots() { DriveInfo[] systemDrive = DriveInfo.GetDrives(); foreach (DriveInfo drive in systemDrive) { listOfRoots.Add(drive.Name); } return listOfRoots; }
} }
FileSearcher.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO;
namespace SearchEngineLib.Search { public class FileSearcher { public String fileToSearch { get; set; } public String driveToSearch { get; set; } //searchresult object private SearchResult sResult = new SearchResult();
public FileSearcher(String _fileToSearch, String _driveToSearch) { fileToSearch = _fileToSearch; driveToSearch = _driveToSearch; } //startsearch,searchforfile,reterive searched file
SearchForFile(fileToSearch, driveToSearch); }
public void SearchForFile(String fileToSearch, String driveToSearch) { try { if (File.Exists(driveToSearch + "\\" + fileToSearch)) { sResult.AddFileFound(driveToSearch + "\\" + fileToSearch); } sResult.NumberOfFoldersScanned++;
String[] dir = Directory.GetDirectories(driveToSearch); foreach (String p in dir) { SearchForFile(fileToSearch, p); } } catch (Exception ex) {
} }
} }
SearchHistoryManager.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO;
namespace SearchEngineLib.Search { public class SearchHistoryManager { public void SaveSearchHistory(SearchLog searchLog, String fileName) { StreamWriter writer = new StreamWriter("E:SearchEngine" + fileName + ".txt"); foreach (String file in searchLog.GetRoots()) { SearchResult sr = searchLog.GetSearchResult(file); foreach (String s in sr.GetFileFound()) { writer.WriteLine(s); } } }
List<String> fileLsit = new List<string>(); try { String line = ""; StreamReader sr = new StreamReader("E:SearchEngine" + driveName + ".txt");
using System.Text;
namespace SearchEngineLib.Search { public class SearchLog { Dictionary<String, SearchResult> searchLog; public SearchLog() { searchLog = new Dictionary<String, SearchResult>();//String(key)=Drivename }
public SearchResult GetSearchResult(String driveName) { //return (SearchResult)searchLog[driveName];//only the search result without drivename return searchLog[driveName];//both drivename and search result }
} }
SearchManager.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.IO;
namespace SearchEngineLib.Search { public class SearchManager { SearchLog sLog = new SearchLog(); int i = 0; public SearchLog StartSearch(List<String> drives, String fileName) { //object filesearch[] FileSearcher[] fileSearcher = new FileSearcher[drives.Count]; //object Thread[] Thread[] thread = new Thread[drives.Count];
fs1 = new FileSearcher(fileName, d); fileSearcher[i] = fs1; t = new Thread(fileSearcher[i].StartSearch); t.Start(); thread[i] = t; i++; }
searchHistoryMgr.SaveSearchHistory(sLog, fileName);
return sLog; } } }
namespace SearchEngineLib.Search { public class SearchResult { public int NumberOfFoldersScanned { get; set; } List<String> filefound; public SearchResult() { filefound = new List<String>(); }
namespace SearchEngineGUI { static class Program { /// <summary> /// The main entry point for the application. /// </summary> [STAThread] static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); }
} }
Form1.cs using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms;
namespace SearchEngineGUI { public partial class Form1 : Form { public Form1() { InitializeComponent(); } List<String> driveSearch = new List<String>(); private void rbtnActive_CheckedChanged(object sender, EventArgs e) { listBox1.Items.Clear(); IRootFinder iRootFinderActive = RootFinderFactory.Create(1); foreach (String s in iRootFinderActive.GetRoots()) listBox1.Items.Add(s);
private void rbtnSystem_CheckedChanged(object sender, EventArgs e) { listBox1.Items.Clear(); IRootFinder iRootFinderSystem = RootFinderFactory.Create(2); foreach (String s in iRootFinderSystem.GetRoots()) listBox1.Items.Add(s); }
{ if (listBox1.Items.Count > 0) { for (int i = 0; i < listBox1.Items.Count; i++) { driveSearch.Add(listBox1.Items[i].ToString()); } listBoxSearchResult.Items.Clear(); StartSearch(); } else { listBoxSearchResult.Items.Add("No Drive Selected......."); } }
public void StartSearch() { String fileName = txtBoxFileName.Text; SearchManager sManager = new SearchManager(); SearchLog log = sManager.StartSearch(driveSearch, fileName); DisplaySearchResult(log); }
{ SearchHistoryManager sm = new SearchHistoryManager(); List<string > l = sm.GetSearchHistory(txtBoxFileName.Text); if (l.Count > 0) { listBoxSearchResult.Items.Add("History Available"); foreach(string f in l){ listBoxSearchResult.Items.Add(f); } } else { listBoxSearchResult.Items.Add("No History Available"); } }
public void DisplaySearchResult(SearchLog sLog) { foreach(string drive in driveSearch) { listBoxSearchResult.Items.Add("Drive "+drive+"---The number foler scanned : "+sLog.GetSearchResult(drive).NumberOfFoldersScanned); foreach(string file in sLog.GetSearchResult(drive).GetFileFound()) { listBoxSearchResult.Items.Add(file); } } } } }
---------------------------------------------------------------------------------------------ThreadsRevision:
Notes.Txt:
Delegate holds the address of objects(methods) two types of delegates: singlecast delegates, multicast delegates. Events are restricted form of delegates. ---------------------------------------------------------------------------Separation of Concern:(OO Principle SRP:Single Responsibility Principle) A class must have a single task and all its methods must do smthng related to that single task only Ex: code to Send alerts must be placed in separate class and code for deposit and withdraw must be placed in a separate class. -----------------------------------------------------------------------------------
OCP:Open CLosed Principle: A class must have only one reason to modify. Classes must be loosely coupled that is they must no depend more on other classes. If we call the SendEmail method of ALert class in Deposit method of Account class to send the emial immediately after a deposit is done, then it is tightly coupled.That is Account class is dependent on Alert class. There is no need for Account class to kno anything about any changes done on the Alert mechanism so we shouldn't call methods of Alert class in Account class. Ex of loosely coupled: If the person wants to kno abt deposits and withdraws he will subscribe for alerts and then only email or sms must be sent. Here Account doesn't have any code to call Alert methods. ALso if there is any change in Alert class Account class need not be changed. Thus they are loosely couple.
BUt still we want to send alert whenever there is a withdrawl or deposit. FOr this we must call Alert methods in Account class. Since aCCOUNT class and Alert class are loosely coupled the Account class doesn't kno the methods of Alert class. Now to call the methods without using their name we use DELEGATEs.
Program.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading;
namespace ThreadsRevision { class Program { static void Main1(string[] args) { Console.WriteLine("Main Thread executed by {0}", Thread.CurrentThread.ManagedThreadId); // displays the id of the thread that is executing here. The id is given br the clr
ThreadStart ts1 = new ThreadStart(Method1);// ts1 is a delegate and it holds the address of Method1. If we want to execute a method in a separate thread other than the main thread, it must and should be void and should not take any parameters. If we want to execute a method with return type other than void in a separate thread then we must call it inside another method which returns void and with no parameters. ThreadStart ts2 = new ThreadStart(Method2);
ParameterizedThreadStart pts1 = new ParameterizedThreadStart(Method4);// pts1 is a delegate which holds the address of Method4. We use ParameterizedThreadStart is a delegate that can hold the address of a method that has a parameter and returns void.
Thus we can run a parameterized method that returns void in a separate thread only if it takes a parameter of type Object.
ThreadStart ts=new ThreadStart(task.Run); Thread t=new Thread(ts); t.Start(); t.Join(); Console.WriteLine("Result {0}",task.Result);//will display 0 as the main thread and child thread are executing parallelly.(chid thread executes the method and main thread executes the COnsole statement).
static void Method2() { Console.WriteLine("Main Thread executed by {0}", Thread.CurrentThread.ManagedThreadId); Console.WriteLine("Method2"); } static int Method3(string s) { return 1; } static void Method4(Object o) { Console.WriteLine(o); } }
//to execute a method that is parameterized and returns anything other than void place it in another class and all the parameters it takes and the values it returns must declared as properties. //the call it inside a method with no return type and void. Noe in another class create a task using SomeTask() and give the task to the delegate ThreadStart . class SomeTask { public string Data1 { get; set; } public string Data2 { get; set; } public int Result { get; set; }
ShortFormToRunParallelThreads.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Diagnostics;// for StopWatch() using System.Threading.Tasks;
namespace ThreadsRevision { class ShortformTO_run_ParallelThreads { static void Main(string[] args) { Stopwatch watch=Stopwatch.StartNew(); Console.WriteLine("Executing sequence...."); //ThreadStart ts1 = new ThreadStart(Method1);// ts1 is a delegate and it holds the address of Method1. If we want to execute a method in a separate thread other than the main thread, it must and should be void and should not take any parameters. If we want
to execute a method with return type other than void in a separate thread then we must call it inside another method which returns void and with no parameters. //ThreadStart ts2 = new ThreadStart(Method2); //Thread t1 = new Thread(ts1); //Thread t2 = new Thread(ts2); //t1.Start(); //t2.Start(); //t1.Join(); //t2.Join(); Parallel.Invoke(Method1, Method2);
Console.WriteLine(watch.ElapsedMilliseconds); //System.Threading.Tasks.Parallel } static void Method1() { //for (int i = 1; i <= 10; i++) Parallel.For(1, 10, i => {
Thread.Sleep(500); });
} static void Method2() { //for (int i = 1; i <= 20; i++) Parallel.For(1, 10, i => {
Thread.Sleep(500); });
} }
DelegatesRevision:
Program.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace DelegatesRevision { class Program { static void Main1(string[] args) { Account acc1 = new Account(); acc1.notify += Alert.SendEmail;//Subscription for email acc1.notify += Alert.SendSMS;//Subscription for email acc1.Deposit(1000); Console.WriteLine(acc1.Balance); acc1.notify -= Alert.SendEmail;//Unsubscription for email //acc1.notify("10000000000000 deposited in your account"); causes error as
"notify" is an event in class Acount and hence cant be raised in any class other than Account. acc1.Deposit(1000); Console.WriteLine(acc1.Balance); acc1.Withdraw(500); Console.WriteLine(500); } }
class Account { public double Balance { get; private set; } public event Notify notify;//=new Notify(Alert.SendMail); we simply just declare a reference variable as Account class doesn't kno the methods of Alert class. //notify is an event and so it can be raised only within this class. We cant raise it in any other class even by using the object of this class. If notify is not an event the it can be called in another class(main program) using account object that is any authorised Account holder can call notify even without doing deposit or withdrawl using the stmt acc1.notify("10000000000000 deposited in your account"); As we made notify as event it cant be done. public void Deposit(double amount) { Balance += amount; if(notify!=null) notify("amount deposited......."); //Alert.SendEmail("amount deposited......."); } public void Withdraw(double amount) {
class Alert { public static void SendEmail(string msg) { //write logic to send email notification Console.WriteLine("Email:{0} " + msg); } public static void SendSMS(string msg) { //write logic to send email notification Console.WriteLine("SMS:{0} " + msg); } } }
Program1.cs
using System; using System.Collections.Generic; using System.Linq;
namespace DelegatesRevision { public delegate bool Filter(Process p); class Program2 { static void Main(string[] args) { //ShowProcessList(); //ShowProcessList("c"); // ShowProcessList(10 * 1024 * 1024); Filter filter = new Filter(FilterByName); ShowProcessList(ByMemSize); ShowProcessList(p => p.ProcessName.EndsWith("a")); //we dont kno on wat basis the client wants to display the processes. so here we use delegates. } static bool ByMemSize(Process p) { if (p.ProcessName.EndsWith("a")) return true; else return false; } static bool FilterByName(Process p) { if (p.ProcessName.EndsWith("a"))
return true; else return false; } static void ShowProcessList(Filter filter)//display all processes { foreach (Process p in Process.GetProcesses()) { if(filter(p)) Console.WriteLine(p.ProcessName); } } //static void ShowProcessList(string sw) //display all processes that start with a particular letter //{ // // // // // //} //static void ShowProcessList(long size)//display all processes whose memory >= given size //{ // // // // // } foreach (Process p in Process.GetProcesses()) { if (p.WorkingSet64>=size) Console.WriteLine(p.ProcessName); } foreach (Process p in Process.GetProcesses()) { if(p.ProcessName.StartsWith(sw)) Console.WriteLine(p.ProcessName);
//} } }
namespace Design1 { interface Interface1 { string getUnit(); string getParadigm(); string getName(); } }
ObjectOriented.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { abstract class ObjectOriented:Interface1 { public string getUnit() { return "Class"; }
} }
Procedural.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
LangJava.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
LangCSharp.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { class LangCSharp:ObjectOriented { public override string getName() { return "CSharp"; } } }
LangC.cs:
using System; using System.Collections.Generic; using System.Linq;
using System.Text;
namespace Design1 { class LangC:Procedural { public override string getName() { return "C"; } } }
Program.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { class Program { static void Main(String[] args) { Interface1 i=null; char c;
switch(choice) { case 1: i=new LangJava(); break; case 2: i=new LangCSharp(); break; case 3: i=new LangC(); break; }; Console.WriteLine("Unit :"+i.getUnit()); Console.WriteLine("Paradigm :"+i.getParadigm()); Console.WriteLine("Name :"+i.getName());
} }
Design2:
Heterogeneous.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { abstract class Heterogeneous:ProgrammingLanguageInterface { Procedural p ; ObjectOriented o ; public Heterogeneous() { p = new LangC(); o = new LangJava(); } public string getUnit() { string unit; unit=p.getUnit() + " and " + o.getUnit(); return unit;
public string getParadigm() { string paradigm; paradigm= p.getParadigm() + " and " + o.getParadigm(); return paradigm; }
} }
LangC.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { class LangC:Procedural { public override string getName() { return "C";
} } }
LangCPP.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { class LangCPP:Heterogeneous { public override string getName() { return "Language CPP"; } } }
LangCSharp.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { class LangCSharp:ObjectOriented { public override string getName() { return "CSharp"; } } }
LangJava.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { class LangJava:ObjectOriented { public override string getName() { return "Java"; } }
ObjectOriented.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { abstract class ObjectOriented:ProgrammingLanguageInterface { public string getUnit() { return "Class"; }
} }
Procedural.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
Program.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design1 { class Program { static void Main(String[] args) { ProgrammingLanguageInterface i=null; char c; int choice; do{
switch(choice) { case 1: i=new LangJava(); break; case 2: i=new LangCSharp(); break; case 3: i=new LangC(); break; case 4: i = new LangCPP(); break; case 5: return; }; Console.WriteLine("Unit :"+i.getUnit()); Console.WriteLine("Paradigm :"+i.getParadigm()); Console.WriteLine("Name :"+i.getName());
ProgrammingLanguageInterface.cs:
using System; using System.Collections.Generic;
namespace Design1 { interface ProgrammingLanguageInterface { string getUnit(); string getParadigm(); string getName(); } }
Design3:
Heterogeneous.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
public Heterogeneous() { p = new ProceduralImplementation(); o = new ObjectOrientedImplementation(); } public string getUnit() { string unit = p.getUnit() +" and "+ o.getUnit(); return unit; }
public string getParadigm() { string paradigm; paradigm = p.getParadigm() + " and " + o.getParadigm(); return paradigm; }
LangC.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design2 { class LangC : Procedural { public override string getName() { return "C"; } } }
LangCPP.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design2 { class LangCPP : Heterogeneous { public override string getName() { return "Java"; } }
LangCSharp.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design2 { class LangCSharp:ObjectOriented { public override string getName() { return "CSharp"; } } }
LangJava.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design2 { class LangJava:ObjectOriented { public override string getName() { return "Java"; } }
ObjectOriented.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design2 { abstract class ObjectOriented:ProgrammingLanguageInterface { public string getUnit() { return "Class"; }
ObjectOrientedImplementation.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design2 { class ObjectOrientedImplementation:ObjectOriented { public override string getName() { return ""; } }
Procedural.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design2 { abstract class Procedural:ProgrammingLanguageInterface { public string getUnit() { return "Function"; }
ProceduralImplementation.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
Program.cs:
using System; using System.Collections.Generic; using System.Linq;
using System.Text;
namespace Design2 { class Program { static void Main(string[] args) { ProgrammingLanguageInterface i = null; char c; int choice; do {
Console.WriteLine("1:Java"); Console.WriteLine("2:C#"); Console.WriteLine("3:C"); Console.WriteLine("4:CPP"); Console.WriteLine("5:exit"); Console.WriteLine("Enter your Choice"); choice = int.Parse(Console.ReadLine());
switch (choice) { case 1: i = new LangJava(); break; case 2: i = new LangCSharp(); break;
case 3: i = new LangC(); break; case 4: i = new LangCPP(); break; case 5: return; }; Console.WriteLine("Unit :" + i.getUnit()); Console.WriteLine("Paradigm :" + i.getParadigm()); Console.WriteLine("Name :" + i.getName());
ProgrammingLanguageInterface.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
Design4:
Heterogeneous.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design3 { abstract class Heterogeneous:ProgrammingLanguageInterface { class ProceduralImplementation : Procedural//inner class (private) { public override string getName() { return ""; } }
Procedural p ; ObjectOriented o ; public Heterogeneous() { p = new ProceduralImplementation(); o = new ObjectOrientedImplementation(); } public string getUnit() { string unit = p.getUnit() + " and " + o.getUnit(); return unit; }
public string getParadigm() { string paradigm; paradigm = p.getParadigm() + " and " + o.getParadigm(); return paradigm; }
} }
LangC.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design3 { class LangC : Procedural { public override string getName() { return "C"; } } }
LangCPP.cs:
using System; using System.Collections.Generic; using System.Linq;
using System.Text;
namespace Design3 { class LangCPP:Heterogeneous { public override string getName() { return "Java"; } } }
LangCSharp.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design3 { class LangCSharp:ObjectOriented { public override string getName() { return "CSharp"; }
} }
LangJava.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design3 { class LangJava:ObjectOriented { public override string getName() { return "Java"; } }
ObjectOriented.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design3 { abstract class ObjectOriented:ProgrammingLanguageInterface { public string getUnit() { return "Class"; }
Procedural.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design3 { abstract class Procedural:ProgrammingLanguageInterface { public string getUnit() { return "Function"; }
Program.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design3 { class Program { static void Main(string[] args) { ProgrammingLanguageInterface i = null; char c; int choice; do {
Console.WriteLine("1:Java"); Console.WriteLine("2:C#"); Console.WriteLine("3:C"); Console.WriteLine("4:CPP"); Console.WriteLine("5:exit"); Console.WriteLine("Enter your Choice"); choice = int.Parse(Console.ReadLine());
switch (choice) { case 1: i = new LangJava(); break; case 2: i = new LangCSharp(); break; case 3: i = new LangC();
break; case 4: i = new LangCPP(); break; case 5: return; }; Console.WriteLine("Unit :" + i.getUnit()); Console.WriteLine("Paradigm :" + i.getParadigm()); Console.WriteLine("Name :" + i.getName());
ProgrammingLanguageInterface.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
Design5:
Heterogeneous.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design4 { abstract class Heterogeneous:ProgrammingLanguageInterface { Procedural p ; ObjectOriented o ; public Heterogeneous() { p = new Procedural(); o = new ObjectOriented(); } public string getUnit() { string unit = p.getUnit() + " and " + o.getUnit(); return unit;
public string getParadigm() { string paradigm; paradigm = p.getParadigm() + " and " + o.getParadigm(); return paradigm; }
} }
LangC.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design4 { class LangC : ProgrammingLanguageInterface { public string getName() { return "C";
return p.getUnit(); }
LangCPP.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
LangCSharp.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design4 { class LangCSharp:ProgrammingLanguageInterface { ObjectOriented o = new ObjectOriented(); public string getUnit() { return o.getUnit(); }
LangJava.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design4 { class LangJava:ProgrammingLanguageInterface { ObjectOriented o = new ObjectOriented(); public string getName() { return "Java"; }
ObjectOriented.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
} }
Procedural.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
} }
Program.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design4 { class Program { static void Main(string[] args) { ProgrammingLanguageInterface i = null; char c; int choice; do {
choice = int.Parse(Console.ReadLine());
switch (choice) { case 1: i = new LangJava(); break; case 2: i = new LangCSharp(); break; case 3: i = new LangC(); break; case 4: i = new LangCPP(); break; case 5: return; }; Console.WriteLine("Unit :" + i.getUnit()); Console.WriteLine("Paradigm :" + i.getParadigm()); Console.WriteLine("Name :" + i.getName());
ProgrammingLanguageInterface.cs:
using System;
namespace Design4 { interface ProgrammingLanguageInterface { string getUnit(); string getParadigm(); string getName(); } }
Design6:
LangC.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
{ p = new Procedural(); }
LangCPP.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design5 { class LangCPP:ProgrammingLanguage { public LangCPP() { o = new ObjectOriented(); p = new Procedural(); } public override string getName()
LangCSharp.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
LangJava.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design5 { class LangJava:ProgrammingLanguage { public LangJava() { o = new ObjectOriented(); } public override string getName() { return "Java"; }
Notes.txt:
ObjectOriented.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
Procedural.cs:
using System; using System.Collections.Generic;
Program.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design5 {
class Program { static void Main(string[] args) { ProgrammingLanguage pl = null; char c; int choice; do {
Console.WriteLine("1:Java"); Console.WriteLine("2:C#"); Console.WriteLine("3:C"); Console.WriteLine("4:CPP"); Console.WriteLine("5:Exit"); Console.WriteLine("Enter your Choice"); choice = int.Parse(Console.ReadLine());
switch (choice) { case 1: pl = new LangJava(); break; case 2: pl = new LangCSharp(); break; case 3: pl = new LangC(); break; case 4: pl = new LangCPP(); break;
case 5: return; }; Console.WriteLine("Unit :" + pl.getUnit()); Console.WriteLine("Paradigm :" + pl.getParadigm()); Console.WriteLine("Name :" + pl.getName());
ProgrammingLanguage.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design5 { abstract class ProgrammingLanguage { public ObjectOriented o = null;//new ObjectOriented(); public Procedural p = null;//new Procedural(); public string getUnit() {
string unit=null; if (o != null) unit = o.getUnit(); if (p != null) unit += p.getUnit(); return unit; }
public string getParadigm() { string paradigm = null; if (o != null) paradigm = o.getParadigm(); if (p != null) paradigm += p.getParadigm(); return paradigm; }
Design7:
LangC.cs:
using System; using System.Collections.Generic;
namespace Design6 { class LangC : ProgrammingLanguage { public override string getName() { return "C Language"; } } }
LangCPP.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design6 { class LangCPP:ProgrammingLanguage { public override string getName() { return "Language CPP";
} } }
LangCSharp.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design6 { class LangCSharp:ProgrammingLanguage { public override string getName() { return "CSharp"; } } }
LangJava.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design6 { class LangJava:ProgrammingLanguage { public override string getName() { return "Java"; }
Methodology.cs:
using System; using System.Collections; using System.Linq; using System.Text;
namespace Design6 { class Methodology { public static IList Objects = new ArrayList(); static Methodology() {
Objects.Add( new Procedural()); Objects.Add(new ObjectOriented()); } public IList getList() { return Objects; } } }
Notes.txt:
we are using two references (drawback in the case of memory management). The drawback of this design is conditional Delegation(checking for condition and then performing the action) in the class ProgrammingLanguage....If there are more types rather than just Procedure and ObjectOriented then usin if else is not feasible. We are not using generic programming in this.
ObjectOriented.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
{ return "Class"; }
Procedural.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
{ return "Procedural"; } } }
Program.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design6 { class Program { static void Main(string[] args) { ProgrammingLanguage pl = null; char c; int choice; do {
switch (choice) { case 1: pl = new LangJava(); break; case 2: pl = new LangCSharp(); break; case 3: pl = new LangC(); break; case 4: pl = new LangCPP(); break; case 5: return; }; Console.WriteLine("Unit :" + pl.getUnit()); Console.WriteLine("Paradigm :" + pl.getParadigm()); Console.WriteLine("Name :" + pl.getName());
ProgrammingLanguage.cs:
using System; using System.Collections; using System.Linq; using System.Text;
namespace Design6 { abstract class ProgrammingLanguage { public string getUnit() { string unit=null; Procedural p=null; ObjectOriented o=null; if(GetType().Name.Equals("LangC"))// (getName().Equals("C Language")) { p = (Procedural)Methodology.Objects[0]; } else if ((GetType().Name.Equals("LangCSharp")) || (GetType().Name.Equals("LangJava"))) { o = (ObjectOriented)Methodology.Objects[1]; } else { p = (Procedural)Methodology.Objects[0]; o = (ObjectOriented)Methodology.Objects[1];
public string getParadigm() { string paradigm = null; Procedural p = null; ObjectOriented o = null; if (GetType().Name.Equals("LangC"))// (getName().Equals("C Language")) { p = (Procedural)Methodology.Objects[0]; } else if ((GetType().Name.Equals("LangCSharp")) || (GetType().Name.Equals("LangJava"))) { o = (ObjectOriented)Methodology.Objects[1]; } else { p = (Procedural)Methodology.Objects[0]; o = (ObjectOriented)Methodology.Objects[1]; } if (o != null)
Design8:
LangC.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
LangCPP.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design7 { class LangCPP:ProgrammingLanguage { ParadigmInterface p1; public LangCPP() { pi = (ObjectOriented)Methodology.Objects[1]; p1 = (Procedural)Methodology.Objects[0]; } public override string getUnit() { return pi.getUnit() + " and " + p1.getUnit(); }
public override string getParadigm() { return pi.getParadigm() + " and " + p1.getParadigm(); } public override string getName() { return "Language CPP"; } } }
LangCSharp.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design7 { class LangCSharp:ProgrammingLanguage { public LangCSharp() { pi = (ObjectOriented)Methodology.Objects[1]; } public override string getName() {
return "CSharp"; } } }
LangJava.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
namespace Design7 { class LangJava:ProgrammingLanguage { public LangJava() { pi = (ObjectOriented)Methodology.Objects[1]; } public override string getName() { return "Java"; }
Methodology.cs:
using System; using System.Collections; using System.Linq; using System.Text;
namespace Design7 { class Methodology { public static IList Objects = new ArrayList(); static Methodology() { Objects.Add( new Procedural()); Objects.Add(new ObjectOriented()); } public IList getList() { return Objects; } } }
Notes.txt:
In this design only two objects are created and placed in a list.
Then we create only one reference in ProgrammngLanguage and used it every where.
TightCoupling avoided Conditional Delegation to be avoided Refractory principlr reduce multilevel inheritance
ObjectOriented.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
} } }
ParadigmInterface.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
Procedural.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
Program.cs:
using System; using System.Collections.Generic; using System.Linq; using System.Text;
Console.WriteLine("1:Java"); Console.WriteLine("2:C#"); Console.WriteLine("3:C"); Console.WriteLine("4:CPP"); Console.WriteLine("5:Exit"); Console.WriteLine("Enter your Choice"); choice = int.Parse(Console.ReadLine());
switch (choice) { case 1: pl = new LangJava(); break; case 2: pl = new LangCSharp(); break; case 3: pl = new LangC(); break; case 4: pl = new LangCPP(); break; case 5: return; }; Console.WriteLine("Unit :" + pl.getUnit());
ProgrammingLanguage.cs:
using System; using System.Collections; using System.Linq; using System.Text;
namespace Design7 { abstract class ProgrammingLanguage { protected ParadigmInterface pi = null; public virtual string getUnit() { string unit = ""; unit = pi.getUnit(); return unit; }