Checklist.dib

#!markdown

# Deadline 1 - Checklist

#!markdown

Deadline is at 2022-10-18 20:00 EEST

- Maximum points if completed by deadline: **1.5**
- Maximum points if completed by 2022-10-11: **1.5 + 0.075**
- Maximum points if completed by 2022-10-04: **1.5 + 0.15**

#!markdown

## Presentation

#!markdown

- You prepared an actual presentation (slides + working app demo) and are ready to present it loud before every other team.
- Every team member can present by himself about tasks he did. It is expected that after presentation (or during presentation) every team member will talk.
- You can present in your code every implemented requirement.

#!markdown

## Goals

#!markdown

### Official goal: to develop an app while working in groups while using material covered in 1-6 lectures.

#!markdown

- You have a **working** (alpha) version of your app.
- You worked as a team.
- You have cooperation proofs (code, commit, pull requests, working app, UI design pictures and etc.)
- Your app implementation uses material from 1-6 lectures.
- **Every** team member knows and understands material covered in 1-6 lectures.

#!markdown

### Unofficial goal: to develop an app in Windows Forms / WPF / Web, that has basic functionality of assigned APP. Understand the usage of GitHub, coding in team principles. Learn to code review yourself and take the feedback when getting one.

#!markdown

- Your app has **working** UI.
- Your app is functional (has at least some kind of working and **usable** functionality). Non-functional requirements (like for example security) do no contribute to word "functional".
- You have a GitHub repository (and I have access to it)
- Your teamwork is represented in your repository (commits from all team members, pull requests and other cooperation proofs)
- You worked using pull requests, your team members commented on your PR (and a least some of the comments required changes, not just "looks good" type of comments), no direct changes on main/master branch.
- **Every** team member used git, made commits, created pull requests, commented on pull requests.

#!markdown

## Requirements

#!markdown

### Creating and using your own class, struct and enum;

#!markdown

- Your app contains at least one **meaningfully** used your own (non-standard) class
- Your app contains at least one **meaningfully** used your own (non-standard) struct
- Your app contains at least one **meaningfully** used your own (non-standard) enum
- **Every** team member can point in your code class, struct and enum + usage of them; can explain why it was implemented like that.
- **Every** team member knows differences between class and struct, how to implement both
- **Every** team member knows what is enum, how to implement it
- **Every** team member knows what is enum with flags, how to implement it


Useful docs:
- [Choosing Between Class and Struct](https://learn.microsoft.com/en-us/dotnet/standard/design-guidelines/choosing-between-class-and-struct)
- [Structure types](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct)
- [Enumeration types](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/enum)
- [Class types](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/class)

#!markdown

### Property usage in struct and class

#!markdown

- Your app contains at least one **meaningfully** used property in class
- Your app contains at least one **meaningfully** used property in struct
- **Every** team member can point in your code properties; explain why it was implemented like that.
- **Every** team member knows all types of properties; can implement them on-site.

Useful docs:
- [Properties](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties)
- [Indexers](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/indexers/)

#!csharp

//This is not meanningful usage of standard property:

class Test
{
    private int _somePropertyBackingField = 0;
    public int SomeProperty { get { return _somePropertyBackingField; } set { _somePropertyBackingField = value; }}
}

#!csharp

class Test
{
    public int SomeProperty { get; set; }
}

#!csharp

//This is kinda meanningful usage of standard property:

class Test
{
    private int _somePropertyBackingField = 0;
    public int SomeProperty { get { return _somePropertyBackingField; } set { _somePropertyBackingField = value; OnPropertyChanged(value); }}

    private void OnPropertyChanged(int newValue)
    {
        //Some tests
    }
}

#!markdown

### Named and optional argument usage

#!markdown

- Your app contains at least one **meaningfully** used named argument
- Your app contains at least one **meaningfully** used optional argument
- **Every** team member can point in your code named and optional argument usage; explain why it was implemented like that.
- **Every** team member knows the meaning behind named and optional arguments, can implement them on-site.

Useful docs:
- [Named and optional arguments](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments)

#!markdown

### Extension method usage

#!markdown

- Your app contains at least one **meaningfully** used extension method
- **Every** team member can point in your code extension method and its usage; explain why it was implemented like that.
- **Every** team member knows and can implement and use extension method on-site.

Note:
- Using extension method on your own class usually is not a meaningful usage (you can just add method directly to your class, you own the code)

Useful docs:
- [Extension methods](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods)

#!markdown

### Reading from file

#!markdown

- Your app contains at least one **meaningfully** used extension reading from file.
- **Every** team member can point in your code where file reading happens; explain why it was implemented like that.
- **Every** team member knows and can implement file reading on-site.
- **Every** team member knows and can use streams, stream readers, using operator.

Note:
- While simplest file reading can be implemented using File.ReadAllText method, for learning purpoise you should use streams and using operator (or at least understand what that is)

Useful docs:
- [Reading from file](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/file-system/how-to-read-from-a-text-file)
- [Using statement](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/using-statement)

#!markdown

### Generic type usage

#!markdown

- Your app contains at least one **meaningfully** used generic type.
- **Every** team member can point in your code where generic type is used; explain why it was implemented like that.
- **Every** team member knows how to use generic types; can implement generic type usage on-site.
- **Every** team member knows how to define new generic types; can implement new generic type on-site.

Note:
- For this requirement it is not mandatory to define new generic types, you can just **meaningfully** use standand generic type, but you must at least know how to implement new generic types.

Useful docs:
- [Generic classes and methods](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/generics)

#!markdown

### Regex usage

#!markdown

- Your app contains at least one **meaningfully** used regex.
- **Every** team member can point in your code where regex is used; explain why it was implemented like that.
- **Every** team member knows how to regex; can implement this on-site.

Note:
- Select meaningful regular expression. Do not use regular expressions for simple checks that can be implemented easily without regex (usually this implementation will be faster).

Useful docs:
- [Regular expressions in .NET](https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expressions)

#!markdown

### Widening and narrowing type conversions

#!markdown

- Your app contains at least one **meaningfully** used widening and one  **meaningfully** used narrowing type conversion.
- **Every** team member can point in your code where type widening/narrowing happens; explain why it was implemented like that.
- **Every** team member knows how to narrow/widen type of variable; can implement this on-site.

Useful docs:
- [Type Conversion](https://learn.microsoft.com/en-us/dotnet/standard/base-types/type-conversion)
- [Type Conversion Tables](https://learn.microsoft.com/en-us/dotnet/standard/base-types/conversion-tables)

#!markdown

### LINQ to Objects usage (methods and queries);

#!markdown

- Your app contains at least one **meaningfully** used LINQ to Objects (query syntax)
- Your app contains at least one **meaningfully** used LINQ to Objects (methods)
- **Every** team member can point in your code where type LINQ to Objecs is used; explain why it was implemented like that.
- **Every** team member knows and can use LINQ to objecs both using query syntax and methods; can implement this on-site.

Note:
- While LINQ to SQL (and LINQ to Entity objects) uses the same syntax it is not LINQ to objects. You are using LINQ to Objects when you query collections (like list, dictionary) or other normal objects (like string). When you query entity framework objects your query is transformed into SQL sentence.

Useful docs:
- [LINQ to Objects](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/linq-to-objects)
- [Basic LINQ Query Operations](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/basic-linq-query-operations)

#!markdown

### Implementing at least one of the standard .NET interfaces (IEnumerable, IComparable, IComparer, IEquatable, IEnumerator, etc.)

#!markdown

- Your app contains at least one **meaningfully** used standard .NET interface
- **Every** team member can point in your code where standard interfaces are used; explain why it was implemented like that.
- **Every** team member knows and can use IComparable/IComparer/IEquatable interfaces; can implement this on-site.
- **Every** team member knows and can use IEnumerator/IEnumerable interfaces; can implement this on-site.

Useful docs:
- [IEquatable](https://learn.microsoft.com/en-us/dotnet/api/system.iequatable-1?view=net-7.0)
- [IComparable](https://learn.microsoft.com/en-us/dotnet/api/system.icomparable-1?view=net-6.0)
- [IComparer](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.icomparer-1?view=net-6.0)
- [IEnumerator](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.ienumerator-1?view=net-6.0)
- [IEnumerable](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.ienumerable-1?view=net-7.0)