-
Notifications
You must be signed in to change notification settings - Fork 0
/
Program.cs
193 lines (164 loc) · 5.3 KB
/
Program.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
using System;
using System.Collections.Generic;
namespace Types
{
class Program
{
//Enum
public enum Days {
None = 0,
Monday = 1,
Tuesday = 2,
Wednesday = 3,
thursday = 4,
Friday = 5,
Saturday = 6,
Sunday = 7
}
//Void
public static void MyMethod(
//Named Argument
int firstArgument,
//Optional Argument
string secondArgument = "default value",
//Optional Argument
bool thirdArgument = false){ }
static void Main(string[] args)
{
//Value type
int random_num = 42;
Console.WriteLine("Value type: {0}", random_num);
//reference type(Enum: Line 20)
var Day = Days.thursday;
Console.WriteLine("From enum: {0}", Day.ToString());
//Using your own type(Line 50)
var my_type = new Point(-23, 122);
//Calling MyMethod(Line 20)
MyMethod(1, thirdArgument: true);
//using Deck class
var deck = new Deck(10);
//Advise user to check out code that wasn't showed:
Console.WriteLine("Please check out my code to see the following: Creating own types(classes) at line 112 & 117, chaining constructors at line 110");
var calc = new Calculator();
//create object of class product
var p = new Product{
Price = 14.99M
};
//Use extenion method and pass new created object as parameter
var total = calc.CalculateDiscount(p);
//return result
Console.WriteLine("From extension method: Price: ${0}", total);
//Virtual Override method
var derived = new Derived();
int val = derived.MyMethod();
Console.WriteLine("From Derived: {0}", val);
}
}
//Own Type
//
//Difference between class and struct: Structs can't have an empty constructor or be inherited from, but a class can
public struct Point {
public int x, y;
//Paramaterized Constructor
public Point(int p1, int p2){
x = p1;
y = p2;
}
}
//Contructor chaining
public class ConstructorChaining {
private int _p;
//Adding multiple constructors to your type
public ConstructorChaining() : this(3) {}
public ConstructorChaining(int p){
this._p = p;
}
}
//Own type 2
public class Card {
public int Number { get; set; }
public string Shape { get; set; }
}
public class Deck {
//public field
public static int _maximumNumberOfCards {get;set;}
//Generic list
public static List<Card> Cards { get; set; }
//Constructor
public Deck(int maximumNumberOfCards){
_maximumNumberOfCards = maximumNumberOfCards;
}
}
//Using Generic Types
//variable where the variable is a value type(Only nullable isn't allowed)
//Where T:
// 1. struct: Value must be value type
// 2. class: Value must be reference type
// 3. new(): Type must have default public constructor
// 4. <Base class name>: Type argument must be derived from specified base class
// 5. <Interface name>: Type must be or implement specified interface
// 6. U: Argument supplied for T must be or derive from arugment supplied for U
public struct Nullable<T> where T: struct
{
private bool hasValue;
private T value;
public Nullable(T value) {
//if value is passed
this.hasValue = true;
//private value = passed value
this.value = value;
}
public bool HasValue { get {return this.hasValue; } }
public T Value {
//If value is accessed
get {
//if value = null, throw Null exception
if(!this.hasValue) throw new ArgumentNullException();
//Otherwise return value
return this.value;
}
}
//Accessible method
public T GetValueOrDefault() {
//return value
return this.value;
}
}
//Extension methods:
//2 ways to extend existing type: 1) Extension methods, 2) Overriding
//1) Extension methods: Calculate discounts on products
public class Product
{
public decimal Price { get; set; }
}
public static class MyExtensions {
//extension method
public static decimal Discount(this Product product){
return product.Price * 0.9M;
}
}
//Calculate discount(using extension method)
public class Calculator {
public decimal CalculateDiscount(Product p){
//use extension method
return p.Discount();
}
}
//2) Overriding methods
//When class is declared as virtual, the method can be overridden from derived class
class Base
{
public virtual int MyMethod(){
return 42;
}
}
//Inherit from base class
class Derived : Base
{
public override int MyMethod()
{
var val = base.MyMethod() * 2;
return val;
}
}
}