Hitta äldsta personen i en array

1. class Person {
2. public string Name;
3. public int Age;
4. public double Height;
5. }
7. public static int FindMaxPerson(Person[] values) {
8. Person max = values[0];
9. foreach (Person x in values) {
10. if (x.Age > max.Age) {
11. max = x;
12. }
13. }
14. return max.Age;
15. }

Anrop med personer

1. Person[] people = new Person[] {
2. new Person {
3. Name = "Cate",
4. Age = 48,
5. Height = 172
6. },
7. new Person {
8. Name = "Brad",
9. Age = 53,
10. Height = 183
11. },
12. new Person {
13. Name = "Zac",
14. Age = 30,
15. Height = 179
16. }
17. };
18. int highestAge = FindMaxPerson(people);

Hitta längsta kursen i en array

1. class Course {
2. public string Name;
3. public string Teacher;
4. public int Points;
5. }
7. public static int FindMaxCourse(Course[] values) {
8. Course max = values[0];
9. foreach (Course x in values) {
10. if (x.Points > max.Points) {
11. max = x;
12. }
13. }
14. return max.Points;
15. }

Anrop med kurser

1. Course[] courses = new Course[] {
2. new Course {
3. Name = "Programmeringsteknik",
4. Teacher = "Jakob",
5. Points = 65
6. },
7. new Course {
8. Name = "Databashantering",
9. Teacher = "Jakob",
10. Points = 15
11. },
12. new Course {
13. Name = "Matematik",
14. Teacher = "Robin",
15. Points = 40
16. }
17. };
18. int highestPoints = FindMaxCourse(courses);

Vad har koden gemensamt?

1. public static int FindMaxCourse(Course[] values) {
2. Course max = values[0];
3. foreach (Course x in values) {
4. if (x.Points > max.Points) {
5. max = x;
6. }
7. }
8. return max.Points;
9. }
11. public static int FindMaxPerson(Person[] values) {
12. Person max = values[0];
13. foreach (Person x in values) {
14. if (x.Age > max.Age) {
15. max = x;
16. }
17. }
18. return max.Age;
19. }

Gemensamma delar

1. public static int FindMax______(______[] values) {
2. ______ max = values[0];
3. foreach (______ x in values) {
4. if (x.______ > max.______) {
5. max = x;
6. }
7. }
8. return max.______;
9. }
11. public static int FindMax______(______[] values) {
12. ______ max = values[0];
13. foreach (______ x in values) {
14. if (x.___ > max.___) {
15. max = x;
16. }
17. }
18. return max.___;
19. }

Generell version med påhittad datatyp

1. public static int FindMax(HasOrder[] values) {
2. HasOrder max = values[0];
3. foreach (HasOrder x in values) {
4. if (x.Order > max.Order) {
5. max = x;
6. }
7. }
8. return max.Order;
9. }

Hur anropar vi metoden?

1. Person[] people = new Person[] {
2. new Person {
3. Name = "Cate",
4. Age = 48,
5. Height = 172
6. },
7. new Person {
8. Name = "Brad",
9. Age = 53,
10. Height = 183
11. },
12. new Person {
13. Name = "Zac",
14. Age = 30,
15. Height = 179
16. }
17. };
18. int highestAge = FindMax(people);

Definiera ett interface

1. interface HasOrder {
2. int Order { get; }
3. }
5. class Person : HasOrder {
6. public string Name;
7. public int Age;
8. public double Height;
9. }

Implementera (uppfylla) ett interface

1. interface HasOrder {
2. int Order { get; }
3. }
5. class Person : HasOrder {
6. public string Name;
7. public int Age;
8. public double Height;
9. public int Order {
10. get {
11. return Age;
12. }
13. }
14. }

Namnkonvention för gränssnitt i C#

1. interface IOrder {
2. int Order { get; }
3. }
5. class Person : IOrder {
6. public string Name;
7. public int Age;
8. public double Height;
9. public int Order {
10. get {
11. return Age;
12. }
13. }
14. }

Nu är koden giltig

1. Person[] people = new Person[] {
2. new Person {
3. Name = "Cate",
4. Age = 48,
5. Height = 172
6. },
7. new Person {
8. Name = "Brad",
9. Age = 53,
10. Height = 183
11. },
12. new Person {
13. Name = "Zac",
14. Age = 30,
15. Height = 179
16. }
17. };
18. int highestAge = FindMax(people);

Samma metod med kurser

1. Course[] courses = new Course[] {
2. new Course {
3. Name = "Programmeringsteknik",
4. Teacher = "Jakob",
5. Points = 65
6. },
7. new Course {
8. Name = "Databashantering",
9. Teacher = "Jakob",
10. Points = 15
11. },
12. new Course {
13. Name = "Matematik",
14. Teacher = "Robin",
15. Points = 40
16. }
17. };
18. int highestPoints = FindMax(courses);

Hur implementerar vi gränssnittet för Course?

1. interface IOrder {
2. int Order { get; }
3. }
5. class Course : IOrder {
6. public string Name;
7. public string Teacher;
8. public int Points;
9. ...
10. ...
11. ...
12. ...
13. ...
14. }

Implementation av gränssnittet för
Course

1. interface IOrder {
2. int Order { get; }
3. }
5. class Course : IOrder {
6. public string Name;
7. public string Teacher;
8. public int Points;
9. public int Order {
10. get {
11. return Points;
12. }
13. }
14. }

Hur implementerar vi gränssnittet för familjer?

1. interface IOrder {
2. int Order { get; }
3. }
5. class Family : IOrder {
6. public string LastName { get; set; }
7. public string City { get; set; }
8. public string[] Members { get; set; }
9. ...
10. ...
11. ...
12. ...
13. ...
14. }

Implementation av gränssnittet för
familjer

1. interface IOrder {
2. int Order { get; }
3. }
5. class Family : IOrder {
6. public string LastName { get; set; }
7. public string City { get; set; }
8. public string[] Members { get; set; }
9. public int Order {
10. get {
11. return Members.Length;
12. }
13. }
14. }

Anrop med familjer

1. Family[] families = new Family[] {
2. new Family {
3. LastName = "Svensson",
4. City = "Stockholm",
5. Members = new string[] {"Anders", "Eva"}
6. },
7. new Family {
8. LastName = "Smith",
9. City = "Chicago",
10. Members = new string[] {"John"}
11. },
12. new Family {
13. LastName = "Kowalski",
14. City = "Warsaw",
15. Members = new string[] {"Maciej", "Ania", "Agata"}
16. }
17. };
18. int mostMembers = FindMax(families);

Gränssnitt för textsökning

1. interface IContains {
2. bool Contains(string search);
3. }
5. class Person : IContains {
6. public string Name;
7. public int Age;
8. public double Height;
9. public bool Contains(string search) {
10. return Name == search;
11. }
12. }
14. class Course : IContains {
15. public string Name;
16. public string Teacher;
17. public int Points;
18. public bool Contains(string search) {
19. return Name == search || Teacher == search;
20. }
21. }

Anrop med personer och kurser

1. Person p = new Person {
2. Name = "Jakob",
3. Age = 30,
4. Height = 181
5. };
6. bool match1 = p.Contains("Jakob");
8. Course c = new Course {
9. Name = "Programmeringsteknik",
10. Teacher = "Jakob",
11. Points = 65
12. };
13. bool match2 = c.Contains("Jakob");

Array med olika klasser men samma gränssnitt

1. IContains[] database = new IContains[] {
2. new Person { Name = "Jakob", ... },
3. new Course { Name = "Programmeringsteknik", ... },
4. ...
5. };
7. int matches = 0;
8. foreach (IContains entry in database) {
9. if (entry.Contains("Jakob")) {
10. matches += 1;
11. }
12. }
13. Console.WriteLine("Found " + matches + " matches");

Samma klass kan implementera flera gränssnitt

1. interface IContains {
2. bool Contains(string search);
3. }
5. interface IOrder {
6. int Order { get; }
7. }
9. class Course : IContains, IOrder {
10. public string Name;
11. public string Teacher;
12. public int Points;
13. public bool Contains(string search) {
14. return Name == search || Teacher == search;
15. }
16. public int Order {
17. get {
18. return Points;
19. }
20. }
21. }

Anrop av båda metoderna med samma klass

1. Course[] courses = new Course[] {
2. new Course {
3. Name = "Programmeringsteknik",
4. Teacher = "Jakob",
5. Points = 65
6. },
7. new Course {
8. Name = "Databashantering",
9. Teacher = "Jakob",
10. Points = 15
11. },
12. new Course {
13. Name = "Matematik",
14. Teacher = "Robin",
15. Points = 40
16. }
17. };
18. int highestPoints = FindMax(courses);
19. if (courses[0].Contains("Jakob")) {
20. ...
21. }

Sammanfattning

• Gränssnitt definierar kontrakt som en klass behöver uppfylla
• Används för klasser som i grunden skiljer sig men ändå har vissa gemensamma drag
• Möjliggör återanvändning av kod och högre abstraktionsnivå
• Steg:
  1. Definiera ett gränssnitt
  2. Implementera gränssnittet för en eller (ofta) flera klasser
  3. Byt ut datatyper i passande argument/variabler från den specifika (klassen) till den generella (gränssnittet)